// Generated from CQL.g4 by ANTLR 4.1

 	package org.zhadoop.stream.cql.semanticanalyzer.parser;
 
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class CQLParser extends Parser {
	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		KW_CREATE=1, KW_SHOW=2, KW_EXPLAIN=3, KW_SET=4, KW_GET=5, KW_LOAD=6, KW_EXPORT=7, 
		KW_DROP=8, KW_ADD=9, KW_SELECT=10, KW_COMMENT=11, KW_FORCE=12, KW_SERDE=13, 
		KW_WITH=14, KW_PROPERTIES=15, KW_SOURCE=16, KW_INPUT=17, KW_STREAM=18, 
		KW_OUTPUT=19, KW_SINK=20, KW_SUBMIT=21, KW_APPLICATION=22, KW_DISTINCT=23, 
		KW_AND=24, KW_OR=25, KW_BETWEEN=26, KW_IN=27, KW_LIKE=28, KW_RLIKE=29, 
		KW_REGEXP=30, KW_CASE=31, KW_WHEN=32, KW_THEN=33, KW_ELSE=34, KW_END=35, 
		KW_CAST=36, KW_EXISTS=37, KW_IF=38, KW_FALSE=39, KW_AS=40, KW_NULL=41, 
		KW_IS=42, KW_TRUE=43, KW_ALL=44, KW_NOT=45, KW_ASC=46, KW_DESC=47, KW_SORT=48, 
		KW_ORDER=49, KW_GROUP=50, KW_BY=51, KW_HAVING=52, KW_WHERE=53, KW_FROM=54, 
		KW_ON=55, KW_JOIN=56, KW_PARALLEL=57, KW_FULL=58, KW_PRESERVE=59, KW_OUTER=60, 
		KW_CROSS=61, KW_SEMI=62, KW_LEFT=63, KW_INNER=64, KW_NATURAL=65, KW_RIGHT=66, 
		KW_INTO=67, KW_INSERT=68, KW_OVERWRITE=69, KW_LIMIT=70, KW_UNION=71, KW_APPLICATIONS=72, 
		KW_WINDOWS=73, KW_EXTENDED=74, KW_FUNCTIONS=75, KW_FILE=76, KW_INPATH=77, 
		KW_WINDOW=78, KW_JAR=79, KW_FUNCTION=80, KW_COMBINE=81, KW_UNIDIRECTION=82, 
		KW_TRIGGER=83, KW_PARTITION=84, KW_SLIDE=85, KW_BATCH=86, KW_RANGE=87, 
		KW_ROWS=88, KW_TODAY=89, KW_UNBOUNDED=90, KW_EXCLUDE=91, KW_NOW=92, KW_PREVIOUS=93, 
		KW_DATASOURCE=94, KW_SCHEMA=95, KW_QUERY=96, KW_DEACTIVE=97, KW_ACTIVE=98, 
		KW_WORKER=99, KW_REBALANCE=100, KW_OPERATOR=101, KW_USING=102, KW_DISTRIBUTE=103, 
		KW_DAY=104, KW_HOUR=105, KW_MINUTES=106, KW_SECONDS=107, KW_MILLISECONDS=108, 
		KW_BOOLEAN=109, KW_INT=110, KW_LONG=111, KW_FLOAT=112, KW_DOUBLE=113, 
		KW_STRING=114, KW_TIMESTAMP=115, KW_DATE=116, KW_TIME=117, KW_DECIMAL=118, 
		DOT=119, COLON=120, COMMA=121, SEMICOLON=122, LPAREN=123, RPAREN=124, 
		LSQUARE=125, RSQUARE=126, LCURLY=127, RCURLY=128, EQUAL=129, EQUAL_NS=130, 
		NOTEQUAL=131, LESSTHANOREQUALTO=132, LESSTHAN=133, GREATERTHANOREQUALTO=134, 
		GREATERTHAN=135, DIVIDE=136, PLUS=137, MINUS=138, CONCATENATION=139, STAR=140, 
		MOD=141, DIV=142, TILDE=143, BITWISEOR=144, AMPERSAND=145, BITWISEXOR=146, 
		QUESTION=147, DOLLAR=148, LongLiteral=149, FloatLiteral=150, DoubleLiteral=151, 
		DecimalLiteral=152, StringLiteral=153, CharSetLiteral=154, IntegerNumber=155, 
		Number=156, Identifier=157, CharSetName=158, WS=159, COMMENT=160, LINE_COMMENT=161;
	public static final String[] tokenNames = {
		"<INVALID>", "'CREATE'", "'SHOW'", "'EXPLAIN'", "'SET'", "'GET'", "'LOAD'", 
		"'EXPORT'", "'DROP'", "'ADD'", "'SELECT'", "'COMMENT'", "'FORCE'", "'SERDE'", 
		"'WITH'", "'PROPERTIES'", "'SOURCE'", "'INPUT'", "'STREAM'", "'OUTPUT'", 
		"'SINK'", "'SUBMIT'", "'APPLICATION'", "'DISTINCT'", "'AND'", "'OR'", 
		"'BETWEEN'", "'IN'", "'LIKE'", "'RLIKE'", "'REGEXP'", "'CASE'", "'WHEN'", 
		"'THEN'", "'ELSE'", "'END'", "'CAST'", "'EXISTS'", "'IF'", "'FALSE'", 
		"'AS'", "'NULL'", "'IS'", "'TRUE'", "'ALL'", "'NOT'", "'ASC'", "'DESC'", 
		"'SORT'", "'ORDER'", "'GROUP'", "'BY'", "'HAVING'", "'WHERE'", "'FROM'", 
		"'ON'", "'JOIN'", "'PARALLEL'", "'FULL'", "'PRESERVE'", "'OUTER'", "'CROSS'", 
		"'SEMI'", "'LEFT'", "'INNER'", "'NATURAL'", "'RIGHT'", "'INTO'", "'INSERT'", 
		"'OVERWRITE'", "'LIMIT'", "'UNION'", "'APPLICATIONS'", "'WINDOWS'", "'EXTENDED'", 
		"'FUNCTIONS'", "'FILE'", "'INPATH'", "'WINDOW'", "'JAR'", "'FUNCTION'", 
		"'COMBINE'", "'UNIDIRECTION'", "'TRIGGER'", "'PARTITION'", "'SLIDE'", 
		"'BATCH'", "'RANGE'", "'ROWS'", "'TODAY'", "'UNBOUNDED'", "'EXCLUDE'", 
		"'NOW'", "'PREVIOUS'", "'DATASOURCE'", "'SCHEMA'", "'QUERY'", "'DEACTIVE'", 
		"'ACTIVE'", "'WORKER'", "'REBALANCE'", "'OPERATOR'", "'USING'", "'DISTRIBUTE'", 
		"KW_DAY", "KW_HOUR", "KW_MINUTES", "KW_SECONDS", "KW_MILLISECONDS", "'BOOLEAN'", 
		"'INT'", "'LONG'", "'FLOAT'", "'DOUBLE'", "'STRING'", "'TIMESTAMP'", "'DATE'", 
		"'TIME'", "'DECIMAL'", "'.'", "':'", "','", "';'", "'('", "')'", "'['", 
		"']'", "'{'", "'}'", "EQUAL", "'<=>'", "NOTEQUAL", "'<='", "'<'", "'>='", 
		"'>'", "'/'", "'+'", "'-'", "'||'", "'*'", "'%'", "'DIV'", "'~'", "'|'", 
		"'&'", "'^'", "'?'", "'$'", "LongLiteral", "FloatLiteral", "DoubleLiteral", 
		"DecimalLiteral", "StringLiteral", "CharSetLiteral", "IntegerNumber", 
		"Number", "Identifier", "CharSetName", "WS", "COMMENT", "LINE_COMMENT"
	};
	public static final int
		RULE_statement = 0, RULE_execStatement = 1, RULE_ddlStatement = 2, RULE_insertStatement = 3, 
		RULE_insertClause = 4, RULE_selectStatement = 5, RULE_selectClause = 6, 
		RULE_fromClause = 7, RULE_whereClause = 8, RULE_searchCondition = 9, RULE_groupByClause = 10, 
		RULE_groupByList = 11, RULE_groupByExpression = 12, RULE_havingClause = 13, 
		RULE_havingCondition = 14, RULE_orderByClause = 15, RULE_columnNameOrderList = 16, 
		RULE_columnNameOrder = 17, RULE_columnOrder = 18, RULE_limitClause = 19, 
		RULE_limitRow = 20, RULE_combineCondition = 21, RULE_subSelectClause = 22, 
		RULE_distinct = 23, RULE_selectList = 24, RULE_selectItem = 25, RULE_selectExpression = 26, 
		RULE_selectAlias = 27, RULE_multialias = 28, RULE_singleAlias = 29, RULE_streamAllColumns = 30, 
		RULE_joinSource = 31, RULE_joinRigthBody = 32, RULE_onCondition = 33, 
		RULE_fromSource = 34, RULE_datasourceBody = 35, RULE_datasourceArguments = 36, 
		RULE_datasourceQuery = 37, RULE_datasourceQueryArguments = 38, RULE_datasourceSchema = 39, 
		RULE_joinToken = 40, RULE_naturalJoin = 41, RULE_crossJoin = 42, RULE_fullJoin = 43, 
		RULE_rightJoin = 44, RULE_leftJoin = 45, RULE_innerJoin = 46, RULE_subQuerySource = 47, 
		RULE_streamBody = 48, RULE_unidirection = 49, RULE_sourceAlias = 50, RULE_streamSource = 51, 
		RULE_createInputStreamStatement = 52, RULE_createOutputStreamStatement = 53, 
		RULE_columnNameTypeList = 54, RULE_serdeDefine = 55, RULE_serdeClass = 56, 
		RULE_serdeProperties = 57, RULE_sourceDefine = 58, RULE_sourceClause = 59, 
		RULE_sourceProperties = 60, RULE_sinkDefine = 61, RULE_sinkClause = 62, 
		RULE_sinkProperties = 63, RULE_parallelClause = 64, RULE_primitiveType = 65, 
		RULE_colType = 66, RULE_columnNameType = 67, RULE_comment = 68, RULE_commentString = 69, 
		RULE_streamPropertiesList = 70, RULE_keyValueProperty = 71, RULE_expression = 72, 
		RULE_logicExpressionOr = 73, RULE_logicExpressionAnd = 74, RULE_logicExpressionNot = 75, 
		RULE_equalRelationExpression = 76, RULE_expressionExists = 77, RULE_isNullLikeInExpressions = 78, 
		RULE_binaryExpression = 79, RULE_expressionLike = 80, RULE_precedenceEqualNegatableOperator = 81, 
		RULE_expressionBetween = 82, RULE_expressionBetweenMaxValue = 83, RULE_expressionBetweenMinValue = 84, 
		RULE_expressionIn = 85, RULE_expressions = 86, RULE_subQueryExpression = 87, 
		RULE_relationExpression = 88, RULE_relationOperator = 89, RULE_bitExpression = 90, 
		RULE_bitOperator = 91, RULE_arithmeticPlusMinusExpression = 92, RULE_arithmeticPlusOperator = 93, 
		RULE_arithmeticStarExpression = 94, RULE_arithmeticStarOperator = 95, 
		RULE_fieldExpression = 96, RULE_atomExpression = 97, RULE_expressionWithLaparen = 98, 
		RULE_whenExpression = 99, RULE_caseExpression = 100, RULE_caseWhenElse = 101, 
		RULE_caseWhenBodyThenBody = 102, RULE_caseWhenBodyWhenBody = 103, RULE_caseHeadExpression = 104, 
		RULE_castExpression = 105, RULE_function = 106, RULE_expressionPrevious = 107, 
		RULE_constant = 108, RULE_booleanValue = 109, RULE_constStingValue = 110, 
		RULE_constIntegerValue = 111, RULE_constBigDecimalValue = 112, RULE_constDoubleValue = 113, 
		RULE_constFloatValue = 114, RULE_constLongValue = 115, RULE_submitApplication = 116, 
		RULE_cqlIdentifier = 117, RULE_streamProperties = 118, RULE_confName = 119, 
		RULE_confValue = 120, RULE_columnName = 121, RULE_className = 122, RULE_innerClassName = 123, 
		RULE_userDefinedClassName = 124, RULE_streamName = 125, RULE_applicationName = 126, 
		RULE_path = 127, RULE_isForce = 128, RULE_columnALias = 129, RULE_identifierNot = 130, 
		RULE_nullCondition = 131, RULE_streamNameOrAlias = 132, RULE_constNull = 133, 
		RULE_unaryOperator = 134, RULE_functionName = 135, RULE_dataSourceName = 136, 
		RULE_streamAlias = 137;
	public static final String[] ruleNames = {
		"statement", "execStatement", "ddlStatement", "insertStatement", "insertClause", 
		"selectStatement", "selectClause", "fromClause", "whereClause", "searchCondition", 
		"groupByClause", "groupByList", "groupByExpression", "havingClause", "havingCondition", 
		"orderByClause", "columnNameOrderList", "columnNameOrder", "columnOrder", 
		"limitClause", "limitRow", "combineCondition", "subSelectClause", "distinct", 
		"selectList", "selectItem", "selectExpression", "selectAlias", "multialias", 
		"singleAlias", "streamAllColumns", "joinSource", "joinRigthBody", "onCondition", 
		"fromSource", "datasourceBody", "datasourceArguments", "datasourceQuery", 
		"datasourceQueryArguments", "datasourceSchema", "joinToken", "naturalJoin", 
		"crossJoin", "fullJoin", "rightJoin", "leftJoin", "innerJoin", "subQuerySource", 
		"streamBody", "unidirection", "sourceAlias", "streamSource", "createInputStreamStatement", 
		"createOutputStreamStatement", "columnNameTypeList", "serdeDefine", "serdeClass", 
		"serdeProperties", "sourceDefine", "sourceClause", "sourceProperties", 
		"sinkDefine", "sinkClause", "sinkProperties", "parallelClause", "primitiveType", 
		"colType", "columnNameType", "comment", "commentString", "streamPropertiesList", 
		"keyValueProperty", "expression", "logicExpressionOr", "logicExpressionAnd", 
		"logicExpressionNot", "equalRelationExpression", "expressionExists", "isNullLikeInExpressions", 
		"binaryExpression", "expressionLike", "precedenceEqualNegatableOperator", 
		"expressionBetween", "expressionBetweenMaxValue", "expressionBetweenMinValue", 
		"expressionIn", "expressions", "subQueryExpression", "relationExpression", 
		"relationOperator", "bitExpression", "bitOperator", "arithmeticPlusMinusExpression", 
		"arithmeticPlusOperator", "arithmeticStarExpression", "arithmeticStarOperator", 
		"fieldExpression", "atomExpression", "expressionWithLaparen", "whenExpression", 
		"caseExpression", "caseWhenElse", "caseWhenBodyThenBody", "caseWhenBodyWhenBody", 
		"caseHeadExpression", "castExpression", "function", "expressionPrevious", 
		"constant", "booleanValue", "constStingValue", "constIntegerValue", "constBigDecimalValue", 
		"constDoubleValue", "constFloatValue", "constLongValue", "submitApplication", 
		"cqlIdentifier", "streamProperties", "confName", "confValue", "columnName", 
		"className", "innerClassName", "userDefinedClassName", "streamName", "applicationName", 
		"path", "isForce", "columnALias", "identifierNot", "nullCondition", "streamNameOrAlias", 
		"constNull", "unaryOperator", "functionName", "dataSourceName", "streamAlias"
	};

	@Override
	public String getGrammarFileName() { return "CQL.g4"; }

	@Override
	public String[] getTokenNames() { return tokenNames; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public ATN getATN() { return _ATN; }

	public CQLParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class StatementContext extends ParserRuleContext {
		public TerminalNode EOF() { return getToken(CQLParser.EOF, 0); }
		public DdlStatementContext ddlStatement() {
			return getRuleContext(DdlStatementContext.class,0);
		}
		public ExecStatementContext execStatement() {
			return getRuleContext(ExecStatementContext.class,0);
		}
		public StatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_statement; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StatementContext statement() throws RecognitionException {
		StatementContext _localctx = new StatementContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_statement);
		try {
			setState(282);
			switch (_input.LA(1)) {
			case KW_CREATE:
			case KW_SUBMIT:
				enterOuterAlt(_localctx, 1);
				{
				setState(276); ddlStatement();
				setState(277); match(EOF);
				}
				break;
			case KW_SELECT:
			case KW_INSERT:
				enterOuterAlt(_localctx, 2);
				{
				setState(279); execStatement();
				setState(280); match(EOF);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExecStatementContext extends ParserRuleContext {
		public InsertStatementContext insertStatement() {
			return getRuleContext(InsertStatementContext.class,0);
		}
		public SelectStatementContext selectStatement() {
			return getRuleContext(SelectStatementContext.class,0);
		}
		public ExecStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_execStatement; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitExecStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExecStatementContext execStatement() throws RecognitionException {
		ExecStatementContext _localctx = new ExecStatementContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_execStatement);
		try {
			setState(286);
			switch (_input.LA(1)) {
			case KW_INSERT:
				enterOuterAlt(_localctx, 1);
				{
				setState(284); insertStatement();
				}
				break;
			case KW_SELECT:
				enterOuterAlt(_localctx, 2);
				{
				setState(285); selectStatement();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DdlStatementContext extends ParserRuleContext {
		public CreateOutputStreamStatementContext createOutputStreamStatement() {
			return getRuleContext(CreateOutputStreamStatementContext.class,0);
		}
		public CreateInputStreamStatementContext createInputStreamStatement() {
			return getRuleContext(CreateInputStreamStatementContext.class,0);
		}
		public SubmitApplicationContext submitApplication() {
			return getRuleContext(SubmitApplicationContext.class,0);
		}
		public DdlStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ddlStatement; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitDdlStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DdlStatementContext ddlStatement() throws RecognitionException {
		DdlStatementContext _localctx = new DdlStatementContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_ddlStatement);
		try {
			setState(291);
			switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(288); createInputStreamStatement();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(289); createOutputStreamStatement();
				}
				break;

			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(290); submitApplication();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class InsertStatementContext extends ParserRuleContext {
		public SelectStatementContext selectStatement() {
			return getRuleContext(SelectStatementContext.class,0);
		}
		public InsertClauseContext insertClause() {
			return getRuleContext(InsertClauseContext.class,0);
		}
		public InsertStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_insertStatement; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitInsertStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final InsertStatementContext insertStatement() throws RecognitionException {
		InsertStatementContext _localctx = new InsertStatementContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_insertStatement);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(293); insertClause();
			setState(294); selectStatement();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class InsertClauseContext extends ParserRuleContext {
		public StreamNameContext streamName() {
			return getRuleContext(StreamNameContext.class,0);
		}
		public TerminalNode KW_INSERT() { return getToken(CQLParser.KW_INSERT, 0); }
		public TerminalNode KW_INTO() { return getToken(CQLParser.KW_INTO, 0); }
		public TerminalNode KW_STREAM() { return getToken(CQLParser.KW_STREAM, 0); }
		public InsertClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_insertClause; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitInsertClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final InsertClauseContext insertClause() throws RecognitionException {
		InsertClauseContext _localctx = new InsertClauseContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_insertClause);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(296); match(KW_INSERT);
			setState(297); match(KW_INTO);
			setState(299);
			_la = _input.LA(1);
			if (_la==KW_STREAM) {
				{
				setState(298); match(KW_STREAM);
				}
			}

			setState(301); streamName();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SelectStatementContext extends ParserRuleContext {
		public OrderByClauseContext orderByClause() {
			return getRuleContext(OrderByClauseContext.class,0);
		}
		public WhereClauseContext whereClause() {
			return getRuleContext(WhereClauseContext.class,0);
		}
		public SelectClauseContext selectClause() {
			return getRuleContext(SelectClauseContext.class,0);
		}
		public HavingClauseContext havingClause() {
			return getRuleContext(HavingClauseContext.class,0);
		}
		public GroupByClauseContext groupByClause() {
			return getRuleContext(GroupByClauseContext.class,0);
		}
		public ParallelClauseContext parallelClause() {
			return getRuleContext(ParallelClauseContext.class,0);
		}
		public FromClauseContext fromClause() {
			return getRuleContext(FromClauseContext.class,0);
		}
		public LimitClauseContext limitClause() {
			return getRuleContext(LimitClauseContext.class,0);
		}
		public SelectStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_selectStatement; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSelectStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SelectStatementContext selectStatement() throws RecognitionException {
		SelectStatementContext _localctx = new SelectStatementContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_selectStatement);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(303); selectClause();
			setState(304); fromClause();
			setState(306);
			_la = _input.LA(1);
			if (_la==KW_WHERE) {
				{
				setState(305); whereClause();
				}
			}

			setState(309);
			_la = _input.LA(1);
			if (_la==KW_GROUP) {
				{
				setState(308); groupByClause();
				}
			}

			setState(312);
			_la = _input.LA(1);
			if (_la==KW_HAVING) {
				{
				setState(311); havingClause();
				}
			}

			setState(315);
			_la = _input.LA(1);
			if (_la==KW_ORDER) {
				{
				setState(314); orderByClause();
				}
			}

			setState(318);
			_la = _input.LA(1);
			if (_la==KW_LIMIT) {
				{
				setState(317); limitClause();
				}
			}

			setState(321);
			_la = _input.LA(1);
			if (_la==KW_PARALLEL) {
				{
				setState(320); parallelClause();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SelectClauseContext extends ParserRuleContext {
		public SubSelectClauseContext subSelectClause() {
			return getRuleContext(SubSelectClauseContext.class,0);
		}
		public TerminalNode KW_SELECT() { return getToken(CQLParser.KW_SELECT, 0); }
		public SelectClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_selectClause; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSelectClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SelectClauseContext selectClause() throws RecognitionException {
		SelectClauseContext _localctx = new SelectClauseContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_selectClause);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(323); match(KW_SELECT);
			setState(324); subSelectClause();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FromClauseContext extends ParserRuleContext {
		public CombineConditionContext combineCondition() {
			return getRuleContext(CombineConditionContext.class,0);
		}
		public TerminalNode KW_FROM() { return getToken(CQLParser.KW_FROM, 0); }
		public JoinSourceContext joinSource() {
			return getRuleContext(JoinSourceContext.class,0);
		}
		public FromClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fromClause; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitFromClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FromClauseContext fromClause() throws RecognitionException {
		FromClauseContext _localctx = new FromClauseContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_fromClause);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(326); match(KW_FROM);
			setState(327); joinSource();
			setState(329);
			_la = _input.LA(1);
			if (_la==KW_COMBINE) {
				{
				setState(328); combineCondition();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class WhereClauseContext extends ParserRuleContext {
		public SearchConditionContext searchCondition() {
			return getRuleContext(SearchConditionContext.class,0);
		}
		public TerminalNode KW_WHERE() { return getToken(CQLParser.KW_WHERE, 0); }
		public WhereClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_whereClause; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitWhereClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final WhereClauseContext whereClause() throws RecognitionException {
		WhereClauseContext _localctx = new WhereClauseContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_whereClause);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(331); match(KW_WHERE);
			setState(332); searchCondition();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SearchConditionContext extends ParserRuleContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public SearchConditionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_searchCondition; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSearchCondition(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SearchConditionContext searchCondition() throws RecognitionException {
		SearchConditionContext _localctx = new SearchConditionContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_searchCondition);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(334); expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class GroupByClauseContext extends ParserRuleContext {
		public GroupByListContext groupByList() {
			return getRuleContext(GroupByListContext.class,0);
		}
		public TerminalNode KW_GROUP() { return getToken(CQLParser.KW_GROUP, 0); }
		public TerminalNode KW_BY() { return getToken(CQLParser.KW_BY, 0); }
		public GroupByClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_groupByClause; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitGroupByClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final GroupByClauseContext groupByClause() throws RecognitionException {
		GroupByClauseContext _localctx = new GroupByClauseContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_groupByClause);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(336); match(KW_GROUP);
			setState(337); match(KW_BY);
			setState(338); groupByList();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class GroupByListContext extends ParserRuleContext {
		public GroupByExpressionContext groupByExpression(int i) {
			return getRuleContext(GroupByExpressionContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(CQLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(CQLParser.COMMA, i);
		}
		public List<GroupByExpressionContext> groupByExpression() {
			return getRuleContexts(GroupByExpressionContext.class);
		}
		public GroupByListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_groupByList; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitGroupByList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final GroupByListContext groupByList() throws RecognitionException {
		GroupByListContext _localctx = new GroupByListContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_groupByList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(340); groupByExpression();
			setState(345);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(341); match(COMMA);
				setState(342); groupByExpression();
				}
				}
				setState(347);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class GroupByExpressionContext extends ParserRuleContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public GroupByExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_groupByExpression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitGroupByExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final GroupByExpressionContext groupByExpression() throws RecognitionException {
		GroupByExpressionContext _localctx = new GroupByExpressionContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_groupByExpression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(348); expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class HavingClauseContext extends ParserRuleContext {
		public HavingConditionContext havingCondition() {
			return getRuleContext(HavingConditionContext.class,0);
		}
		public TerminalNode KW_HAVING() { return getToken(CQLParser.KW_HAVING, 0); }
		public HavingClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_havingClause; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitHavingClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final HavingClauseContext havingClause() throws RecognitionException {
		HavingClauseContext _localctx = new HavingClauseContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_havingClause);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(350); match(KW_HAVING);
			setState(351); havingCondition();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class HavingConditionContext extends ParserRuleContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public HavingConditionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_havingCondition; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitHavingCondition(this);
			else return visitor.visitChildren(this);
		}
	}

	public final HavingConditionContext havingCondition() throws RecognitionException {
		HavingConditionContext _localctx = new HavingConditionContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_havingCondition);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(353); expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OrderByClauseContext extends ParserRuleContext {
		public TerminalNode KW_ORDER() { return getToken(CQLParser.KW_ORDER, 0); }
		public ColumnNameOrderListContext columnNameOrderList() {
			return getRuleContext(ColumnNameOrderListContext.class,0);
		}
		public TerminalNode KW_BY() { return getToken(CQLParser.KW_BY, 0); }
		public OrderByClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_orderByClause; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitOrderByClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OrderByClauseContext orderByClause() throws RecognitionException {
		OrderByClauseContext _localctx = new OrderByClauseContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_orderByClause);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(355); match(KW_ORDER);
			setState(356); match(KW_BY);
			setState(357); columnNameOrderList();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ColumnNameOrderListContext extends ParserRuleContext {
		public List<TerminalNode> COMMA() { return getTokens(CQLParser.COMMA); }
		public ColumnNameOrderContext columnNameOrder(int i) {
			return getRuleContext(ColumnNameOrderContext.class,i);
		}
		public List<ColumnNameOrderContext> columnNameOrder() {
			return getRuleContexts(ColumnNameOrderContext.class);
		}
		public TerminalNode COMMA(int i) {
			return getToken(CQLParser.COMMA, i);
		}
		public ColumnNameOrderListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_columnNameOrderList; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitColumnNameOrderList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ColumnNameOrderListContext columnNameOrderList() throws RecognitionException {
		ColumnNameOrderListContext _localctx = new ColumnNameOrderListContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_columnNameOrderList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(359); columnNameOrder();
			setState(364);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(360); match(COMMA);
				setState(361); columnNameOrder();
				}
				}
				setState(366);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ColumnNameOrderContext extends ParserRuleContext {
		public ColumnOrderContext columnOrder() {
			return getRuleContext(ColumnOrderContext.class,0);
		}
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public ColumnNameOrderContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_columnNameOrder; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitColumnNameOrder(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ColumnNameOrderContext columnNameOrder() throws RecognitionException {
		ColumnNameOrderContext _localctx = new ColumnNameOrderContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_columnNameOrder);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(367); expression();
			setState(369);
			_la = _input.LA(1);
			if (_la==KW_ASC || _la==KW_DESC) {
				{
				setState(368); columnOrder();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ColumnOrderContext extends ParserRuleContext {
		public TerminalNode KW_ASC() { return getToken(CQLParser.KW_ASC, 0); }
		public TerminalNode KW_DESC() { return getToken(CQLParser.KW_DESC, 0); }
		public ColumnOrderContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_columnOrder; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitColumnOrder(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ColumnOrderContext columnOrder() throws RecognitionException {
		ColumnOrderContext _localctx = new ColumnOrderContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_columnOrder);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(371);
			_la = _input.LA(1);
			if ( !(_la==KW_ASC || _la==KW_DESC) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LimitClauseContext extends ParserRuleContext {
		public LimitRowContext limitRow() {
			return getRuleContext(LimitRowContext.class,0);
		}
		public TerminalNode KW_LIMIT() { return getToken(CQLParser.KW_LIMIT, 0); }
		public LimitClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_limitClause; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitLimitClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LimitClauseContext limitClause() throws RecognitionException {
		LimitClauseContext _localctx = new LimitClauseContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_limitClause);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(373); match(KW_LIMIT);
			setState(374); limitRow();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LimitRowContext extends ParserRuleContext {
		public ConstIntegerValueContext constIntegerValue() {
			return getRuleContext(ConstIntegerValueContext.class,0);
		}
		public LimitRowContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_limitRow; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitLimitRow(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LimitRowContext limitRow() throws RecognitionException {
		LimitRowContext _localctx = new LimitRowContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_limitRow);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(376); constIntegerValue();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CombineConditionContext extends ParserRuleContext {
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode KW_COMBINE() { return getToken(CQLParser.KW_COMBINE, 0); }
		public List<TerminalNode> COMMA() { return getTokens(CQLParser.COMMA); }
		public TerminalNode RPAREN() { return getToken(CQLParser.RPAREN, 0); }
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public TerminalNode LPAREN() { return getToken(CQLParser.LPAREN, 0); }
		public TerminalNode COMMA(int i) {
			return getToken(CQLParser.COMMA, i);
		}
		public CombineConditionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_combineCondition; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitCombineCondition(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CombineConditionContext combineCondition() throws RecognitionException {
		CombineConditionContext _localctx = new CombineConditionContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_combineCondition);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(378); match(KW_COMBINE);
			setState(379); match(LPAREN);
			setState(380); expression();
			setState(383); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(381); match(COMMA);
				setState(382); expression();
				}
				}
				setState(385); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==COMMA );
			setState(387); match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SubSelectClauseContext extends ParserRuleContext {
		public DistinctContext distinct() {
			return getRuleContext(DistinctContext.class,0);
		}
		public SelectListContext selectList() {
			return getRuleContext(SelectListContext.class,0);
		}
		public SubSelectClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_subSelectClause; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSubSelectClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SubSelectClauseContext subSelectClause() throws RecognitionException {
		SubSelectClauseContext _localctx = new SubSelectClauseContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_subSelectClause);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(390);
			_la = _input.LA(1);
			if (_la==KW_DISTINCT) {
				{
				setState(389); distinct();
				}
			}

			setState(392); selectList();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DistinctContext extends ParserRuleContext {
		public TerminalNode KW_DISTINCT() { return getToken(CQLParser.KW_DISTINCT, 0); }
		public DistinctContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_distinct; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitDistinct(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DistinctContext distinct() throws RecognitionException {
		DistinctContext _localctx = new DistinctContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_distinct);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(394); match(KW_DISTINCT);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SelectListContext extends ParserRuleContext {
		public List<SelectItemContext> selectItem() {
			return getRuleContexts(SelectItemContext.class);
		}
		public List<TerminalNode> COMMA() { return getTokens(CQLParser.COMMA); }
		public SelectItemContext selectItem(int i) {
			return getRuleContext(SelectItemContext.class,i);
		}
		public TerminalNode COMMA(int i) {
			return getToken(CQLParser.COMMA, i);
		}
		public SelectListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_selectList; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSelectList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SelectListContext selectList() throws RecognitionException {
		SelectListContext _localctx = new SelectListContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_selectList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(396); selectItem();
			setState(401);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(397); match(COMMA);
				setState(398); selectItem();
				}
				}
				setState(403);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SelectItemContext extends ParserRuleContext {
		public SelectExpressionContext selectExpression() {
			return getRuleContext(SelectExpressionContext.class,0);
		}
		public SelectItemContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_selectItem; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSelectItem(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SelectItemContext selectItem() throws RecognitionException {
		SelectItemContext _localctx = new SelectItemContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_selectItem);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(404); selectExpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SelectExpressionContext extends ParserRuleContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public SelectAliasContext selectAlias() {
			return getRuleContext(SelectAliasContext.class,0);
		}
		public StreamAllColumnsContext streamAllColumns() {
			return getRuleContext(StreamAllColumnsContext.class,0);
		}
		public SelectExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_selectExpression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSelectExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SelectExpressionContext selectExpression() throws RecognitionException {
		SelectExpressionContext _localctx = new SelectExpressionContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_selectExpression);
		int _la;
		try {
			setState(411);
			switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(406); expression();
				setState(408);
				_la = _input.LA(1);
				if (_la==KW_AS || ((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & ((1L << (KW_OPERATOR - 101)) | (1L << (KW_DAY - 101)) | (1L << (KW_HOUR - 101)) | (1L << (KW_MINUTES - 101)) | (1L << (KW_SECONDS - 101)) | (1L << (KW_MILLISECONDS - 101)) | (1L << (KW_BOOLEAN - 101)) | (1L << (KW_INT - 101)) | (1L << (KW_LONG - 101)) | (1L << (KW_FLOAT - 101)) | (1L << (KW_STRING - 101)) | (1L << (KW_TIMESTAMP - 101)) | (1L << (KW_DATE - 101)) | (1L << (KW_TIME - 101)) | (1L << (KW_DECIMAL - 101)) | (1L << (Identifier - 101)))) != 0)) {
					{
					setState(407); selectAlias();
					}
				}

				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(410); streamAllColumns();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SelectAliasContext extends ParserRuleContext {
		public SingleAliasContext singleAlias() {
			return getRuleContext(SingleAliasContext.class,0);
		}
		public MultialiasContext multialias() {
			return getRuleContext(MultialiasContext.class,0);
		}
		public SelectAliasContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_selectAlias; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSelectAlias(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SelectAliasContext selectAlias() throws RecognitionException {
		SelectAliasContext _localctx = new SelectAliasContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_selectAlias);
		try {
			setState(415);
			switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(413); multialias();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(414); singleAlias();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MultialiasContext extends ParserRuleContext {
		public List<ColumnALiasContext> columnALias() {
			return getRuleContexts(ColumnALiasContext.class);
		}
		public TerminalNode KW_AS() { return getToken(CQLParser.KW_AS, 0); }
		public ColumnALiasContext columnALias(int i) {
			return getRuleContext(ColumnALiasContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(CQLParser.COMMA); }
		public TerminalNode RPAREN() { return getToken(CQLParser.RPAREN, 0); }
		public TerminalNode LPAREN() { return getToken(CQLParser.LPAREN, 0); }
		public TerminalNode COMMA(int i) {
			return getToken(CQLParser.COMMA, i);
		}
		public MultialiasContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_multialias; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitMultialias(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MultialiasContext multialias() throws RecognitionException {
		MultialiasContext _localctx = new MultialiasContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_multialias);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(417); match(KW_AS);
			setState(418); match(LPAREN);
			setState(419); columnALias();
			setState(424);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(420); match(COMMA);
				setState(421); columnALias();
				}
				}
				setState(426);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(427); match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SingleAliasContext extends ParserRuleContext {
		public TerminalNode KW_AS() { return getToken(CQLParser.KW_AS, 0); }
		public ColumnALiasContext columnALias() {
			return getRuleContext(ColumnALiasContext.class,0);
		}
		public SingleAliasContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_singleAlias; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSingleAlias(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SingleAliasContext singleAlias() throws RecognitionException {
		SingleAliasContext _localctx = new SingleAliasContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_singleAlias);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(430);
			_la = _input.LA(1);
			if (_la==KW_AS) {
				{
				setState(429); match(KW_AS);
				}
			}

			setState(432); columnALias();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class StreamAllColumnsContext extends ParserRuleContext {
		public StreamNameContext streamName() {
			return getRuleContext(StreamNameContext.class,0);
		}
		public TerminalNode DOT() { return getToken(CQLParser.DOT, 0); }
		public TerminalNode STAR() { return getToken(CQLParser.STAR, 0); }
		public StreamAllColumnsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_streamAllColumns; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitStreamAllColumns(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StreamAllColumnsContext streamAllColumns() throws RecognitionException {
		StreamAllColumnsContext _localctx = new StreamAllColumnsContext(_ctx, getState());
		enterRule(_localctx, 60, RULE_streamAllColumns);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(437);
			_la = _input.LA(1);
			if (((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & ((1L << (KW_OPERATOR - 101)) | (1L << (KW_DAY - 101)) | (1L << (KW_HOUR - 101)) | (1L << (KW_MINUTES - 101)) | (1L << (KW_SECONDS - 101)) | (1L << (KW_MILLISECONDS - 101)) | (1L << (KW_BOOLEAN - 101)) | (1L << (KW_INT - 101)) | (1L << (KW_LONG - 101)) | (1L << (KW_FLOAT - 101)) | (1L << (KW_STRING - 101)) | (1L << (KW_TIMESTAMP - 101)) | (1L << (KW_DATE - 101)) | (1L << (KW_TIME - 101)) | (1L << (KW_DECIMAL - 101)) | (1L << (Identifier - 101)))) != 0)) {
				{
				setState(434); streamName();
				setState(435); match(DOT);
				}
			}

			setState(439); match(STAR);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class JoinSourceContext extends ParserRuleContext {
		public JoinRigthBodyContext joinRigthBody(int i) {
			return getRuleContext(JoinRigthBodyContext.class,i);
		}
		public List<JoinRigthBodyContext> joinRigthBody() {
			return getRuleContexts(JoinRigthBodyContext.class);
		}
		public FromSourceContext fromSource() {
			return getRuleContext(FromSourceContext.class,0);
		}
		public JoinSourceContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_joinSource; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitJoinSource(this);
			else return visitor.visitChildren(this);
		}
	}

	public final JoinSourceContext joinSource() throws RecognitionException {
		JoinSourceContext _localctx = new JoinSourceContext(_ctx, getState());
		enterRule(_localctx, 62, RULE_joinSource);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(441); fromSource();
			setState(445);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << KW_JOIN) | (1L << KW_FULL) | (1L << KW_CROSS) | (1L << KW_LEFT))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (KW_INNER - 64)) | (1L << (KW_NATURAL - 64)) | (1L << (KW_RIGHT - 64)) | (1L << (COMMA - 64)))) != 0)) {
				{
				{
				setState(442); joinRigthBody();
				}
				}
				setState(447);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class JoinRigthBodyContext extends ParserRuleContext {
		public JoinTokenContext joinToken() {
			return getRuleContext(JoinTokenContext.class,0);
		}
		public OnConditionContext onCondition() {
			return getRuleContext(OnConditionContext.class,0);
		}
		public FromSourceContext fromSource() {
			return getRuleContext(FromSourceContext.class,0);
		}
		public JoinRigthBodyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_joinRigthBody; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitJoinRigthBody(this);
			else return visitor.visitChildren(this);
		}
	}

	public final JoinRigthBodyContext joinRigthBody() throws RecognitionException {
		JoinRigthBodyContext _localctx = new JoinRigthBodyContext(_ctx, getState());
		enterRule(_localctx, 64, RULE_joinRigthBody);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(448); joinToken();
			setState(449); fromSource();
			setState(451);
			_la = _input.LA(1);
			if (_la==KW_ON) {
				{
				setState(450); onCondition();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OnConditionContext extends ParserRuleContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode KW_ON() { return getToken(CQLParser.KW_ON, 0); }
		public OnConditionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_onCondition; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitOnCondition(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OnConditionContext onCondition() throws RecognitionException {
		OnConditionContext _localctx = new OnConditionContext(_ctx, getState());
		enterRule(_localctx, 66, RULE_onCondition);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(453); match(KW_ON);
			setState(454); expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FromSourceContext extends ParserRuleContext {
		public StreamBodyContext streamBody() {
			return getRuleContext(StreamBodyContext.class,0);
		}
		public DatasourceBodyContext datasourceBody() {
			return getRuleContext(DatasourceBodyContext.class,0);
		}
		public FromSourceContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fromSource; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitFromSource(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FromSourceContext fromSource() throws RecognitionException {
		FromSourceContext _localctx = new FromSourceContext(_ctx, getState());
		enterRule(_localctx, 68, RULE_fromSource);
		try {
			setState(458);
			switch (_input.LA(1)) {
			case KW_OPERATOR:
			case KW_DAY:
			case KW_HOUR:
			case KW_MINUTES:
			case KW_SECONDS:
			case KW_MILLISECONDS:
			case KW_BOOLEAN:
			case KW_INT:
			case KW_LONG:
			case KW_FLOAT:
			case KW_STRING:
			case KW_TIMESTAMP:
			case KW_DATE:
			case KW_TIME:
			case KW_DECIMAL:
			case LPAREN:
			case Identifier:
				enterOuterAlt(_localctx, 1);
				{
				setState(456); streamBody();
				}
				break;
			case KW_DATASOURCE:
				enterOuterAlt(_localctx, 2);
				{
				setState(457); datasourceBody();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DatasourceBodyContext extends ParserRuleContext {
		public DataSourceNameContext dataSourceName() {
			return getRuleContext(DataSourceNameContext.class,0);
		}
		public SourceAliasContext sourceAlias() {
			return getRuleContext(SourceAliasContext.class,0);
		}
		public TerminalNode KW_DATASOURCE() { return getToken(CQLParser.KW_DATASOURCE, 0); }
		public DatasourceArgumentsContext datasourceArguments() {
			return getRuleContext(DatasourceArgumentsContext.class,0);
		}
		public DatasourceBodyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_datasourceBody; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitDatasourceBody(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DatasourceBodyContext datasourceBody() throws RecognitionException {
		DatasourceBodyContext _localctx = new DatasourceBodyContext(_ctx, getState());
		enterRule(_localctx, 70, RULE_datasourceBody);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(460); match(KW_DATASOURCE);
			setState(461); dataSourceName();
			setState(462); datasourceArguments();
			setState(464);
			_la = _input.LA(1);
			if (_la==KW_AS || ((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & ((1L << (KW_OPERATOR - 101)) | (1L << (KW_DAY - 101)) | (1L << (KW_HOUR - 101)) | (1L << (KW_MINUTES - 101)) | (1L << (KW_SECONDS - 101)) | (1L << (KW_MILLISECONDS - 101)) | (1L << (KW_BOOLEAN - 101)) | (1L << (KW_INT - 101)) | (1L << (KW_LONG - 101)) | (1L << (KW_FLOAT - 101)) | (1L << (KW_STRING - 101)) | (1L << (KW_TIMESTAMP - 101)) | (1L << (KW_DATE - 101)) | (1L << (KW_TIME - 101)) | (1L << (KW_DECIMAL - 101)) | (1L << (Identifier - 101)))) != 0)) {
				{
				setState(463); sourceAlias();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DatasourceArgumentsContext extends ParserRuleContext {
		public DatasourceSchemaContext datasourceSchema() {
			return getRuleContext(DatasourceSchemaContext.class,0);
		}
		public TerminalNode RSQUARE() { return getToken(CQLParser.RSQUARE, 0); }
		public DatasourceQueryContext datasourceQuery() {
			return getRuleContext(DatasourceQueryContext.class,0);
		}
		public TerminalNode COMMA() { return getToken(CQLParser.COMMA, 0); }
		public TerminalNode LSQUARE() { return getToken(CQLParser.LSQUARE, 0); }
		public DatasourceArgumentsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_datasourceArguments; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitDatasourceArguments(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DatasourceArgumentsContext datasourceArguments() throws RecognitionException {
		DatasourceArgumentsContext _localctx = new DatasourceArgumentsContext(_ctx, getState());
		enterRule(_localctx, 72, RULE_datasourceArguments);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(466); match(LSQUARE);
			setState(467); datasourceSchema();
			setState(468); match(COMMA);
			setState(469); datasourceQuery();
			setState(470); match(RSQUARE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DatasourceQueryContext extends ParserRuleContext {
		public DatasourceQueryArgumentsContext datasourceQueryArguments() {
			return getRuleContext(DatasourceQueryArgumentsContext.class,0);
		}
		public TerminalNode KW_QUERY() { return getToken(CQLParser.KW_QUERY, 0); }
		public TerminalNode RPAREN() { return getToken(CQLParser.RPAREN, 0); }
		public TerminalNode LPAREN() { return getToken(CQLParser.LPAREN, 0); }
		public DatasourceQueryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_datasourceQuery; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitDatasourceQuery(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DatasourceQueryContext datasourceQuery() throws RecognitionException {
		DatasourceQueryContext _localctx = new DatasourceQueryContext(_ctx, getState());
		enterRule(_localctx, 74, RULE_datasourceQuery);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(472); match(KW_QUERY);
			setState(473); match(LPAREN);
			setState(475);
			_la = _input.LA(1);
			if (((((_la - 31)) & ~0x3f) == 0 && ((1L << (_la - 31)) & ((1L << (KW_CASE - 31)) | (1L << (KW_CAST - 31)) | (1L << (KW_EXISTS - 31)) | (1L << (KW_FALSE - 31)) | (1L << (KW_NULL - 31)) | (1L << (KW_TRUE - 31)) | (1L << (KW_NOT - 31)) | (1L << (KW_PREVIOUS - 31)))) != 0) || ((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & ((1L << (KW_OPERATOR - 101)) | (1L << (KW_DAY - 101)) | (1L << (KW_HOUR - 101)) | (1L << (KW_MINUTES - 101)) | (1L << (KW_SECONDS - 101)) | (1L << (KW_MILLISECONDS - 101)) | (1L << (KW_BOOLEAN - 101)) | (1L << (KW_INT - 101)) | (1L << (KW_LONG - 101)) | (1L << (KW_FLOAT - 101)) | (1L << (KW_STRING - 101)) | (1L << (KW_TIMESTAMP - 101)) | (1L << (KW_DATE - 101)) | (1L << (KW_TIME - 101)) | (1L << (KW_DECIMAL - 101)) | (1L << (LPAREN - 101)) | (1L << (PLUS - 101)) | (1L << (MINUS - 101)) | (1L << (TILDE - 101)) | (1L << (LongLiteral - 101)) | (1L << (FloatLiteral - 101)) | (1L << (DoubleLiteral - 101)) | (1L << (DecimalLiteral - 101)) | (1L << (StringLiteral - 101)) | (1L << (IntegerNumber - 101)) | (1L << (Identifier - 101)))) != 0)) {
				{
				setState(474); datasourceQueryArguments();
				}
			}

			setState(477); match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DatasourceQueryArgumentsContext extends ParserRuleContext {
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(CQLParser.COMMA); }
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public TerminalNode COMMA(int i) {
			return getToken(CQLParser.COMMA, i);
		}
		public DatasourceQueryArgumentsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_datasourceQueryArguments; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitDatasourceQueryArguments(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DatasourceQueryArgumentsContext datasourceQueryArguments() throws RecognitionException {
		DatasourceQueryArgumentsContext _localctx = new DatasourceQueryArgumentsContext(_ctx, getState());
		enterRule(_localctx, 76, RULE_datasourceQueryArguments);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(479); expression();
			setState(484);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(480); match(COMMA);
				setState(481); expression();
				}
				}
				setState(486);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DatasourceSchemaContext extends ParserRuleContext {
		public ColumnNameTypeListContext columnNameTypeList() {
			return getRuleContext(ColumnNameTypeListContext.class,0);
		}
		public TerminalNode RPAREN() { return getToken(CQLParser.RPAREN, 0); }
		public TerminalNode KW_SCHEMA() { return getToken(CQLParser.KW_SCHEMA, 0); }
		public TerminalNode LPAREN() { return getToken(CQLParser.LPAREN, 0); }
		public DatasourceSchemaContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_datasourceSchema; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitDatasourceSchema(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DatasourceSchemaContext datasourceSchema() throws RecognitionException {
		DatasourceSchemaContext _localctx = new DatasourceSchemaContext(_ctx, getState());
		enterRule(_localctx, 78, RULE_datasourceSchema);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(487); match(KW_SCHEMA);
			setState(488); match(LPAREN);
			setState(489); columnNameTypeList();
			setState(490); match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class JoinTokenContext extends ParserRuleContext {
		public FullJoinContext fullJoin() {
			return getRuleContext(FullJoinContext.class,0);
		}
		public InnerJoinContext innerJoin() {
			return getRuleContext(InnerJoinContext.class,0);
		}
		public RightJoinContext rightJoin() {
			return getRuleContext(RightJoinContext.class,0);
		}
		public LeftJoinContext leftJoin() {
			return getRuleContext(LeftJoinContext.class,0);
		}
		public CrossJoinContext crossJoin() {
			return getRuleContext(CrossJoinContext.class,0);
		}
		public NaturalJoinContext naturalJoin() {
			return getRuleContext(NaturalJoinContext.class,0);
		}
		public JoinTokenContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_joinToken; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitJoinToken(this);
			else return visitor.visitChildren(this);
		}
	}

	public final JoinTokenContext joinToken() throws RecognitionException {
		JoinTokenContext _localctx = new JoinTokenContext(_ctx, getState());
		enterRule(_localctx, 80, RULE_joinToken);
		try {
			setState(498);
			switch (_input.LA(1)) {
			case KW_JOIN:
			case KW_INNER:
				enterOuterAlt(_localctx, 1);
				{
				setState(492); innerJoin();
				}
				break;
			case KW_LEFT:
				enterOuterAlt(_localctx, 2);
				{
				setState(493); leftJoin();
				}
				break;
			case KW_RIGHT:
				enterOuterAlt(_localctx, 3);
				{
				setState(494); rightJoin();
				}
				break;
			case KW_FULL:
				enterOuterAlt(_localctx, 4);
				{
				setState(495); fullJoin();
				}
				break;
			case KW_CROSS:
			case COMMA:
				enterOuterAlt(_localctx, 5);
				{
				setState(496); crossJoin();
				}
				break;
			case KW_NATURAL:
				enterOuterAlt(_localctx, 6);
				{
				setState(497); naturalJoin();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class NaturalJoinContext extends ParserRuleContext {
		public TerminalNode KW_NATURAL() { return getToken(CQLParser.KW_NATURAL, 0); }
		public TerminalNode KW_JOIN() { return getToken(CQLParser.KW_JOIN, 0); }
		public NaturalJoinContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_naturalJoin; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitNaturalJoin(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NaturalJoinContext naturalJoin() throws RecognitionException {
		NaturalJoinContext _localctx = new NaturalJoinContext(_ctx, getState());
		enterRule(_localctx, 82, RULE_naturalJoin);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(500); match(KW_NATURAL);
			setState(501); match(KW_JOIN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CrossJoinContext extends ParserRuleContext {
		public TerminalNode KW_CROSS() { return getToken(CQLParser.KW_CROSS, 0); }
		public TerminalNode COMMA() { return getToken(CQLParser.COMMA, 0); }
		public TerminalNode KW_JOIN() { return getToken(CQLParser.KW_JOIN, 0); }
		public CrossJoinContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_crossJoin; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitCrossJoin(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CrossJoinContext crossJoin() throws RecognitionException {
		CrossJoinContext _localctx = new CrossJoinContext(_ctx, getState());
		enterRule(_localctx, 84, RULE_crossJoin);
		try {
			setState(506);
			switch (_input.LA(1)) {
			case COMMA:
				enterOuterAlt(_localctx, 1);
				{
				setState(503); match(COMMA);
				}
				break;
			case KW_CROSS:
				enterOuterAlt(_localctx, 2);
				{
				setState(504); match(KW_CROSS);
				setState(505); match(KW_JOIN);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FullJoinContext extends ParserRuleContext {
		public TerminalNode KW_OUTER() { return getToken(CQLParser.KW_OUTER, 0); }
		public TerminalNode KW_JOIN() { return getToken(CQLParser.KW_JOIN, 0); }
		public TerminalNode KW_FULL() { return getToken(CQLParser.KW_FULL, 0); }
		public FullJoinContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fullJoin; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitFullJoin(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FullJoinContext fullJoin() throws RecognitionException {
		FullJoinContext _localctx = new FullJoinContext(_ctx, getState());
		enterRule(_localctx, 86, RULE_fullJoin);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(508); match(KW_FULL);
			setState(510);
			_la = _input.LA(1);
			if (_la==KW_OUTER) {
				{
				setState(509); match(KW_OUTER);
				}
			}

			setState(512); match(KW_JOIN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RightJoinContext extends ParserRuleContext {
		public TerminalNode KW_RIGHT() { return getToken(CQLParser.KW_RIGHT, 0); }
		public TerminalNode KW_OUTER() { return getToken(CQLParser.KW_OUTER, 0); }
		public TerminalNode KW_JOIN() { return getToken(CQLParser.KW_JOIN, 0); }
		public RightJoinContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rightJoin; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitRightJoin(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RightJoinContext rightJoin() throws RecognitionException {
		RightJoinContext _localctx = new RightJoinContext(_ctx, getState());
		enterRule(_localctx, 88, RULE_rightJoin);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(514); match(KW_RIGHT);
			setState(516);
			_la = _input.LA(1);
			if (_la==KW_OUTER) {
				{
				setState(515); match(KW_OUTER);
				}
			}

			setState(518); match(KW_JOIN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LeftJoinContext extends ParserRuleContext {
		public TerminalNode KW_OUTER() { return getToken(CQLParser.KW_OUTER, 0); }
		public TerminalNode KW_LEFT() { return getToken(CQLParser.KW_LEFT, 0); }
		public TerminalNode KW_JOIN() { return getToken(CQLParser.KW_JOIN, 0); }
		public LeftJoinContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_leftJoin; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitLeftJoin(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LeftJoinContext leftJoin() throws RecognitionException {
		LeftJoinContext _localctx = new LeftJoinContext(_ctx, getState());
		enterRule(_localctx, 90, RULE_leftJoin);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(520); match(KW_LEFT);
			setState(522);
			_la = _input.LA(1);
			if (_la==KW_OUTER) {
				{
				setState(521); match(KW_OUTER);
				}
			}

			setState(524); match(KW_JOIN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class InnerJoinContext extends ParserRuleContext {
		public TerminalNode KW_INNER() { return getToken(CQLParser.KW_INNER, 0); }
		public TerminalNode KW_JOIN() { return getToken(CQLParser.KW_JOIN, 0); }
		public InnerJoinContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_innerJoin; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitInnerJoin(this);
			else return visitor.visitChildren(this);
		}
	}

	public final InnerJoinContext innerJoin() throws RecognitionException {
		InnerJoinContext _localctx = new InnerJoinContext(_ctx, getState());
		enterRule(_localctx, 92, RULE_innerJoin);
		try {
			setState(529);
			switch (_input.LA(1)) {
			case KW_JOIN:
				enterOuterAlt(_localctx, 1);
				{
				setState(526); match(KW_JOIN);
				}
				break;
			case KW_INNER:
				enterOuterAlt(_localctx, 2);
				{
				setState(527); match(KW_INNER);
				setState(528); match(KW_JOIN);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SubQuerySourceContext extends ParserRuleContext {
		public TerminalNode RPAREN() { return getToken(CQLParser.RPAREN, 0); }
		public SelectStatementContext selectStatement() {
			return getRuleContext(SelectStatementContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(CQLParser.LPAREN, 0); }
		public SubQuerySourceContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_subQuerySource; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSubQuerySource(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SubQuerySourceContext subQuerySource() throws RecognitionException {
		SubQuerySourceContext _localctx = new SubQuerySourceContext(_ctx, getState());
		enterRule(_localctx, 94, RULE_subQuerySource);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(531); match(LPAREN);
			setState(532); selectStatement();
			setState(533); match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class StreamBodyContext extends ParserRuleContext {
		public SourceAliasContext sourceAlias() {
			return getRuleContext(SourceAliasContext.class,0);
		}
		public StreamSourceContext streamSource() {
			return getRuleContext(StreamSourceContext.class,0);
		}
		public UnidirectionContext unidirection() {
			return getRuleContext(UnidirectionContext.class,0);
		}
		public StreamBodyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_streamBody; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitStreamBody(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StreamBodyContext streamBody() throws RecognitionException {
		StreamBodyContext _localctx = new StreamBodyContext(_ctx, getState());
		enterRule(_localctx, 96, RULE_streamBody);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(535); streamSource();
			setState(537);
			_la = _input.LA(1);
			if (_la==KW_AS || ((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & ((1L << (KW_OPERATOR - 101)) | (1L << (KW_DAY - 101)) | (1L << (KW_HOUR - 101)) | (1L << (KW_MINUTES - 101)) | (1L << (KW_SECONDS - 101)) | (1L << (KW_MILLISECONDS - 101)) | (1L << (KW_BOOLEAN - 101)) | (1L << (KW_INT - 101)) | (1L << (KW_LONG - 101)) | (1L << (KW_FLOAT - 101)) | (1L << (KW_STRING - 101)) | (1L << (KW_TIMESTAMP - 101)) | (1L << (KW_DATE - 101)) | (1L << (KW_TIME - 101)) | (1L << (KW_DECIMAL - 101)) | (1L << (Identifier - 101)))) != 0)) {
				{
				setState(536); sourceAlias();
				}
			}

			setState(540);
			_la = _input.LA(1);
			if (_la==KW_UNIDIRECTION) {
				{
				setState(539); unidirection();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UnidirectionContext extends ParserRuleContext {
		public TerminalNode KW_UNIDIRECTION() { return getToken(CQLParser.KW_UNIDIRECTION, 0); }
		public UnidirectionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unidirection; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitUnidirection(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UnidirectionContext unidirection() throws RecognitionException {
		UnidirectionContext _localctx = new UnidirectionContext(_ctx, getState());
		enterRule(_localctx, 98, RULE_unidirection);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(542); match(KW_UNIDIRECTION);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SourceAliasContext extends ParserRuleContext {
		public TerminalNode KW_AS() { return getToken(CQLParser.KW_AS, 0); }
		public StreamAliasContext streamAlias() {
			return getRuleContext(StreamAliasContext.class,0);
		}
		public SourceAliasContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sourceAlias; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSourceAlias(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SourceAliasContext sourceAlias() throws RecognitionException {
		SourceAliasContext _localctx = new SourceAliasContext(_ctx, getState());
		enterRule(_localctx, 100, RULE_sourceAlias);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(545);
			_la = _input.LA(1);
			if (_la==KW_AS) {
				{
				setState(544); match(KW_AS);
				}
			}

			setState(547); streamAlias();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class StreamSourceContext extends ParserRuleContext {
		public SubQuerySourceContext subQuerySource() {
			return getRuleContext(SubQuerySourceContext.class,0);
		}
		public StreamNameContext streamName() {
			return getRuleContext(StreamNameContext.class,0);
		}
		public StreamSourceContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_streamSource; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitStreamSource(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StreamSourceContext streamSource() throws RecognitionException {
		StreamSourceContext _localctx = new StreamSourceContext(_ctx, getState());
		enterRule(_localctx, 102, RULE_streamSource);
		try {
			setState(551);
			switch (_input.LA(1)) {
			case KW_OPERATOR:
			case KW_DAY:
			case KW_HOUR:
			case KW_MINUTES:
			case KW_SECONDS:
			case KW_MILLISECONDS:
			case KW_BOOLEAN:
			case KW_INT:
			case KW_LONG:
			case KW_FLOAT:
			case KW_STRING:
			case KW_TIMESTAMP:
			case KW_DATE:
			case KW_TIME:
			case KW_DECIMAL:
			case Identifier:
				enterOuterAlt(_localctx, 1);
				{
				setState(549); streamName();
				}
				break;
			case LPAREN:
				enterOuterAlt(_localctx, 2);
				{
				setState(550); subQuerySource();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CreateInputStreamStatementContext extends ParserRuleContext {
		public StreamNameContext streamName() {
			return getRuleContext(StreamNameContext.class,0);
		}
		public SerdeDefineContext serdeDefine() {
			return getRuleContext(SerdeDefineContext.class,0);
		}
		public CommentContext comment() {
			return getRuleContext(CommentContext.class,0);
		}
		public ColumnNameTypeListContext columnNameTypeList() {
			return getRuleContext(ColumnNameTypeListContext.class,0);
		}
		public TerminalNode KW_CREATE() { return getToken(CQLParser.KW_CREATE, 0); }
		public TerminalNode RPAREN() { return getToken(CQLParser.RPAREN, 0); }
		public TerminalNode KW_INPUT() { return getToken(CQLParser.KW_INPUT, 0); }
		public ParallelClauseContext parallelClause() {
			return getRuleContext(ParallelClauseContext.class,0);
		}
		public SourceDefineContext sourceDefine() {
			return getRuleContext(SourceDefineContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(CQLParser.LPAREN, 0); }
		public TerminalNode KW_STREAM() { return getToken(CQLParser.KW_STREAM, 0); }
		public CreateInputStreamStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_createInputStreamStatement; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitCreateInputStreamStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CreateInputStreamStatementContext createInputStreamStatement() throws RecognitionException {
		CreateInputStreamStatementContext _localctx = new CreateInputStreamStatementContext(_ctx, getState());
		enterRule(_localctx, 104, RULE_createInputStreamStatement);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(553); match(KW_CREATE);
			setState(554); match(KW_INPUT);
			setState(555); match(KW_STREAM);
			setState(556); streamName();
			setState(561);
			_la = _input.LA(1);
			if (_la==LPAREN) {
				{
				setState(557); match(LPAREN);
				setState(558); columnNameTypeList();
				setState(559); match(RPAREN);
				}
			}

			setState(564);
			_la = _input.LA(1);
			if (_la==KW_COMMENT) {
				{
				setState(563); comment();
				}
			}

			setState(567);
			_la = _input.LA(1);
			if (_la==KW_SERDE) {
				{
				setState(566); serdeDefine();
				}
			}

			setState(569); sourceDefine();
			setState(571);
			_la = _input.LA(1);
			if (_la==KW_PARALLEL) {
				{
				setState(570); parallelClause();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CreateOutputStreamStatementContext extends ParserRuleContext {
		public StreamNameContext streamName() {
			return getRuleContext(StreamNameContext.class,0);
		}
		public SerdeDefineContext serdeDefine() {
			return getRuleContext(SerdeDefineContext.class,0);
		}
		public CommentContext comment() {
			return getRuleContext(CommentContext.class,0);
		}
		public ColumnNameTypeListContext columnNameTypeList() {
			return getRuleContext(ColumnNameTypeListContext.class,0);
		}
		public TerminalNode KW_CREATE() { return getToken(CQLParser.KW_CREATE, 0); }
		public TerminalNode RPAREN() { return getToken(CQLParser.RPAREN, 0); }
		public ParallelClauseContext parallelClause() {
			return getRuleContext(ParallelClauseContext.class,0);
		}
		public TerminalNode KW_OUTPUT() { return getToken(CQLParser.KW_OUTPUT, 0); }
		public TerminalNode LPAREN() { return getToken(CQLParser.LPAREN, 0); }
		public SinkDefineContext sinkDefine() {
			return getRuleContext(SinkDefineContext.class,0);
		}
		public TerminalNode KW_STREAM() { return getToken(CQLParser.KW_STREAM, 0); }
		public CreateOutputStreamStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_createOutputStreamStatement; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitCreateOutputStreamStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CreateOutputStreamStatementContext createOutputStreamStatement() throws RecognitionException {
		CreateOutputStreamStatementContext _localctx = new CreateOutputStreamStatementContext(_ctx, getState());
		enterRule(_localctx, 106, RULE_createOutputStreamStatement);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(573); match(KW_CREATE);
			setState(574); match(KW_OUTPUT);
			setState(575); match(KW_STREAM);
			setState(576); streamName();
			setState(581);
			_la = _input.LA(1);
			if (_la==LPAREN) {
				{
				setState(577); match(LPAREN);
				setState(578); columnNameTypeList();
				setState(579); match(RPAREN);
				}
			}

			setState(584);
			_la = _input.LA(1);
			if (_la==KW_COMMENT) {
				{
				setState(583); comment();
				}
			}

			setState(587);
			_la = _input.LA(1);
			if (_la==KW_SERDE) {
				{
				setState(586); serdeDefine();
				}
			}

			setState(589); sinkDefine();
			setState(591);
			_la = _input.LA(1);
			if (_la==KW_PARALLEL) {
				{
				setState(590); parallelClause();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ColumnNameTypeListContext extends ParserRuleContext {
		public List<TerminalNode> COMMA() { return getTokens(CQLParser.COMMA); }
		public ColumnNameTypeContext columnNameType(int i) {
			return getRuleContext(ColumnNameTypeContext.class,i);
		}
		public TerminalNode COMMA(int i) {
			return getToken(CQLParser.COMMA, i);
		}
		public List<ColumnNameTypeContext> columnNameType() {
			return getRuleContexts(ColumnNameTypeContext.class);
		}
		public ColumnNameTypeListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_columnNameTypeList; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitColumnNameTypeList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ColumnNameTypeListContext columnNameTypeList() throws RecognitionException {
		ColumnNameTypeListContext _localctx = new ColumnNameTypeListContext(_ctx, getState());
		enterRule(_localctx, 108, RULE_columnNameTypeList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(593); columnNameType();
			setState(598);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(594); match(COMMA);
				setState(595); columnNameType();
				}
				}
				setState(600);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SerdeDefineContext extends ParserRuleContext {
		public SerdePropertiesContext serdeProperties() {
			return getRuleContext(SerdePropertiesContext.class,0);
		}
		public SerdeClassContext serdeClass() {
			return getRuleContext(SerdeClassContext.class,0);
		}
		public SerdeDefineContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_serdeDefine; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSerdeDefine(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SerdeDefineContext serdeDefine() throws RecognitionException {
		SerdeDefineContext _localctx = new SerdeDefineContext(_ctx, getState());
		enterRule(_localctx, 110, RULE_serdeDefine);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(601); serdeClass();
			setState(603);
			_la = _input.LA(1);
			if (_la==KW_PROPERTIES) {
				{
				setState(602); serdeProperties();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SerdeClassContext extends ParserRuleContext {
		public ClassNameContext className() {
			return getRuleContext(ClassNameContext.class,0);
		}
		public TerminalNode KW_SERDE() { return getToken(CQLParser.KW_SERDE, 0); }
		public SerdeClassContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_serdeClass; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSerdeClass(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SerdeClassContext serdeClass() throws RecognitionException {
		SerdeClassContext _localctx = new SerdeClassContext(_ctx, getState());
		enterRule(_localctx, 112, RULE_serdeClass);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(605); match(KW_SERDE);
			setState(606); className();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SerdePropertiesContext extends ParserRuleContext {
		public StreamPropertiesContext streamProperties() {
			return getRuleContext(StreamPropertiesContext.class,0);
		}
		public SerdePropertiesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_serdeProperties; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSerdeProperties(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SerdePropertiesContext serdeProperties() throws RecognitionException {
		SerdePropertiesContext _localctx = new SerdePropertiesContext(_ctx, getState());
		enterRule(_localctx, 114, RULE_serdeProperties);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(608); streamProperties();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SourceDefineContext extends ParserRuleContext {
		public SourceClauseContext sourceClause() {
			return getRuleContext(SourceClauseContext.class,0);
		}
		public SourcePropertiesContext sourceProperties() {
			return getRuleContext(SourcePropertiesContext.class,0);
		}
		public SourceDefineContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sourceDefine; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSourceDefine(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SourceDefineContext sourceDefine() throws RecognitionException {
		SourceDefineContext _localctx = new SourceDefineContext(_ctx, getState());
		enterRule(_localctx, 116, RULE_sourceDefine);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(610); sourceClause();
			setState(612);
			_la = _input.LA(1);
			if (_la==KW_PROPERTIES) {
				{
				setState(611); sourceProperties();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SourceClauseContext extends ParserRuleContext {
		public ClassNameContext className() {
			return getRuleContext(ClassNameContext.class,0);
		}
		public TerminalNode KW_SOURCE() { return getToken(CQLParser.KW_SOURCE, 0); }
		public SourceClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sourceClause; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSourceClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SourceClauseContext sourceClause() throws RecognitionException {
		SourceClauseContext _localctx = new SourceClauseContext(_ctx, getState());
		enterRule(_localctx, 118, RULE_sourceClause);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(614); match(KW_SOURCE);
			setState(615); className();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SourcePropertiesContext extends ParserRuleContext {
		public StreamPropertiesContext streamProperties() {
			return getRuleContext(StreamPropertiesContext.class,0);
		}
		public SourcePropertiesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sourceProperties; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSourceProperties(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SourcePropertiesContext sourceProperties() throws RecognitionException {
		SourcePropertiesContext _localctx = new SourcePropertiesContext(_ctx, getState());
		enterRule(_localctx, 120, RULE_sourceProperties);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(617); streamProperties();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SinkDefineContext extends ParserRuleContext {
		public SinkClauseContext sinkClause() {
			return getRuleContext(SinkClauseContext.class,0);
		}
		public SinkPropertiesContext sinkProperties() {
			return getRuleContext(SinkPropertiesContext.class,0);
		}
		public SinkDefineContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sinkDefine; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSinkDefine(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SinkDefineContext sinkDefine() throws RecognitionException {
		SinkDefineContext _localctx = new SinkDefineContext(_ctx, getState());
		enterRule(_localctx, 122, RULE_sinkDefine);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(619); sinkClause();
			setState(621);
			_la = _input.LA(1);
			if (_la==KW_PROPERTIES) {
				{
				setState(620); sinkProperties();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SinkClauseContext extends ParserRuleContext {
		public ClassNameContext className() {
			return getRuleContext(ClassNameContext.class,0);
		}
		public TerminalNode KW_SINK() { return getToken(CQLParser.KW_SINK, 0); }
		public SinkClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sinkClause; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSinkClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SinkClauseContext sinkClause() throws RecognitionException {
		SinkClauseContext _localctx = new SinkClauseContext(_ctx, getState());
		enterRule(_localctx, 124, RULE_sinkClause);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(623); match(KW_SINK);
			setState(624); className();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SinkPropertiesContext extends ParserRuleContext {
		public StreamPropertiesContext streamProperties() {
			return getRuleContext(StreamPropertiesContext.class,0);
		}
		public SinkPropertiesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sinkProperties; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSinkProperties(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SinkPropertiesContext sinkProperties() throws RecognitionException {
		SinkPropertiesContext _localctx = new SinkPropertiesContext(_ctx, getState());
		enterRule(_localctx, 126, RULE_sinkProperties);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(626); streamProperties();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ParallelClauseContext extends ParserRuleContext {
		public TerminalNode KW_PARALLEL() { return getToken(CQLParser.KW_PARALLEL, 0); }
		public ConstIntegerValueContext constIntegerValue() {
			return getRuleContext(ConstIntegerValueContext.class,0);
		}
		public ParallelClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_parallelClause; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitParallelClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParallelClauseContext parallelClause() throws RecognitionException {
		ParallelClauseContext _localctx = new ParallelClauseContext(_ctx, getState());
		enterRule(_localctx, 128, RULE_parallelClause);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(628); match(KW_PARALLEL);
			setState(629); constIntegerValue();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PrimitiveTypeContext extends ParserRuleContext {
		public TerminalNode KW_INT() { return getToken(CQLParser.KW_INT, 0); }
		public TerminalNode KW_DECIMAL() { return getToken(CQLParser.KW_DECIMAL, 0); }
		public TerminalNode KW_BOOLEAN() { return getToken(CQLParser.KW_BOOLEAN, 0); }
		public TerminalNode KW_TIMESTAMP() { return getToken(CQLParser.KW_TIMESTAMP, 0); }
		public TerminalNode KW_TIME() { return getToken(CQLParser.KW_TIME, 0); }
		public TerminalNode KW_DOUBLE() { return getToken(CQLParser.KW_DOUBLE, 0); }
		public TerminalNode KW_FLOAT() { return getToken(CQLParser.KW_FLOAT, 0); }
		public TerminalNode KW_LONG() { return getToken(CQLParser.KW_LONG, 0); }
		public TerminalNode KW_STRING() { return getToken(CQLParser.KW_STRING, 0); }
		public TerminalNode KW_DATE() { return getToken(CQLParser.KW_DATE, 0); }
		public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_primitiveType; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitPrimitiveType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PrimitiveTypeContext primitiveType() throws RecognitionException {
		PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState());
		enterRule(_localctx, 130, RULE_primitiveType);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(631);
			_la = _input.LA(1);
			if ( !(((((_la - 109)) & ~0x3f) == 0 && ((1L << (_la - 109)) & ((1L << (KW_BOOLEAN - 109)) | (1L << (KW_INT - 109)) | (1L << (KW_LONG - 109)) | (1L << (KW_FLOAT - 109)) | (1L << (KW_DOUBLE - 109)) | (1L << (KW_STRING - 109)) | (1L << (KW_TIMESTAMP - 109)) | (1L << (KW_DATE - 109)) | (1L << (KW_TIME - 109)) | (1L << (KW_DECIMAL - 109)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ColTypeContext extends ParserRuleContext {
		public PrimitiveTypeContext primitiveType() {
			return getRuleContext(PrimitiveTypeContext.class,0);
		}
		public ColTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_colType; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitColType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ColTypeContext colType() throws RecognitionException {
		ColTypeContext _localctx = new ColTypeContext(_ctx, getState());
		enterRule(_localctx, 132, RULE_colType);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(633); primitiveType();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ColumnNameTypeContext extends ParserRuleContext {
		public CommentContext comment() {
			return getRuleContext(CommentContext.class,0);
		}
		public ColumnNameContext columnName() {
			return getRuleContext(ColumnNameContext.class,0);
		}
		public ColTypeContext colType() {
			return getRuleContext(ColTypeContext.class,0);
		}
		public ColumnNameTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_columnNameType; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitColumnNameType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ColumnNameTypeContext columnNameType() throws RecognitionException {
		ColumnNameTypeContext _localctx = new ColumnNameTypeContext(_ctx, getState());
		enterRule(_localctx, 134, RULE_columnNameType);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(635); columnName();
			setState(636); colType();
			setState(638);
			_la = _input.LA(1);
			if (_la==KW_COMMENT) {
				{
				setState(637); comment();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CommentContext extends ParserRuleContext {
		public TerminalNode KW_COMMENT() { return getToken(CQLParser.KW_COMMENT, 0); }
		public CommentStringContext commentString() {
			return getRuleContext(CommentStringContext.class,0);
		}
		public CommentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_comment; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitComment(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CommentContext comment() throws RecognitionException {
		CommentContext _localctx = new CommentContext(_ctx, getState());
		enterRule(_localctx, 136, RULE_comment);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(640); match(KW_COMMENT);
			setState(641); commentString();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CommentStringContext extends ParserRuleContext {
		public TerminalNode StringLiteral() { return getToken(CQLParser.StringLiteral, 0); }
		public CommentStringContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_commentString; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitCommentString(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CommentStringContext commentString() throws RecognitionException {
		CommentStringContext _localctx = new CommentStringContext(_ctx, getState());
		enterRule(_localctx, 138, RULE_commentString);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(643); match(StringLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class StreamPropertiesListContext extends ParserRuleContext {
		public KeyValuePropertyContext keyValueProperty(int i) {
			return getRuleContext(KeyValuePropertyContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(CQLParser.COMMA); }
		public List<KeyValuePropertyContext> keyValueProperty() {
			return getRuleContexts(KeyValuePropertyContext.class);
		}
		public TerminalNode COMMA(int i) {
			return getToken(CQLParser.COMMA, i);
		}
		public StreamPropertiesListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_streamPropertiesList; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitStreamPropertiesList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StreamPropertiesListContext streamPropertiesList() throws RecognitionException {
		StreamPropertiesListContext _localctx = new StreamPropertiesListContext(_ctx, getState());
		enterRule(_localctx, 140, RULE_streamPropertiesList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(645); keyValueProperty();
			setState(650);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(646); match(COMMA);
				setState(647); keyValueProperty();
				}
				}
				setState(652);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class KeyValuePropertyContext extends ParserRuleContext {
		public ConfValueContext confValue() {
			return getRuleContext(ConfValueContext.class,0);
		}
		public ConfNameContext confName() {
			return getRuleContext(ConfNameContext.class,0);
		}
		public TerminalNode EQUAL() { return getToken(CQLParser.EQUAL, 0); }
		public KeyValuePropertyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_keyValueProperty; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitKeyValueProperty(this);
			else return visitor.visitChildren(this);
		}
	}

	public final KeyValuePropertyContext keyValueProperty() throws RecognitionException {
		KeyValuePropertyContext _localctx = new KeyValuePropertyContext(_ctx, getState());
		enterRule(_localctx, 142, RULE_keyValueProperty);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(653); confName();
			setState(654); match(EQUAL);
			setState(655); confValue();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExpressionContext extends ParserRuleContext {
		public LogicExpressionOrContext logicExpressionOr() {
			return getRuleContext(LogicExpressionOrContext.class,0);
		}
		public ExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionContext expression() throws RecognitionException {
		ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
		enterRule(_localctx, 144, RULE_expression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(657); logicExpressionOr();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LogicExpressionOrContext extends ParserRuleContext {
		public LogicExpressionAndContext logicExpressionAnd(int i) {
			return getRuleContext(LogicExpressionAndContext.class,i);
		}
		public TerminalNode KW_OR(int i) {
			return getToken(CQLParser.KW_OR, i);
		}
		public List<TerminalNode> KW_OR() { return getTokens(CQLParser.KW_OR); }
		public List<LogicExpressionAndContext> logicExpressionAnd() {
			return getRuleContexts(LogicExpressionAndContext.class);
		}
		public LogicExpressionOrContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_logicExpressionOr; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitLogicExpressionOr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LogicExpressionOrContext logicExpressionOr() throws RecognitionException {
		LogicExpressionOrContext _localctx = new LogicExpressionOrContext(_ctx, getState());
		enterRule(_localctx, 146, RULE_logicExpressionOr);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(659); logicExpressionAnd();
			setState(664);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,53,_ctx);
			while ( _alt!=2 && _alt!=-1 ) {
				if ( _alt==1 ) {
					{
					{
					setState(660); match(KW_OR);
					setState(661); logicExpressionAnd();
					}
					} 
				}
				setState(666);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,53,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LogicExpressionAndContext extends ParserRuleContext {
		public LogicExpressionNotContext logicExpressionNot(int i) {
			return getRuleContext(LogicExpressionNotContext.class,i);
		}
		public List<LogicExpressionNotContext> logicExpressionNot() {
			return getRuleContexts(LogicExpressionNotContext.class);
		}
		public TerminalNode KW_AND() { return getToken(CQLParser.KW_AND, 0); }
		public LogicExpressionAndContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_logicExpressionAnd; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitLogicExpressionAnd(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LogicExpressionAndContext logicExpressionAnd() throws RecognitionException {
		LogicExpressionAndContext _localctx = new LogicExpressionAndContext(_ctx, getState());
		enterRule(_localctx, 148, RULE_logicExpressionAnd);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(667); logicExpressionNot();
			{
			setState(668); match(KW_AND);
			setState(669); logicExpressionNot();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LogicExpressionNotContext extends ParserRuleContext {
		public EqualRelationExpressionContext equalRelationExpression() {
			return getRuleContext(EqualRelationExpressionContext.class,0);
		}
		public IdentifierNotContext identifierNot() {
			return getRuleContext(IdentifierNotContext.class,0);
		}
		public LogicExpressionNotContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_logicExpressionNot; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitLogicExpressionNot(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LogicExpressionNotContext logicExpressionNot() throws RecognitionException {
		LogicExpressionNotContext _localctx = new LogicExpressionNotContext(_ctx, getState());
		enterRule(_localctx, 150, RULE_logicExpressionNot);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(672);
			_la = _input.LA(1);
			if (_la==KW_NOT) {
				{
				setState(671); identifierNot();
				}
			}

			setState(674); equalRelationExpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EqualRelationExpressionContext extends ParserRuleContext {
		public IsNullLikeInExpressionsContext isNullLikeInExpressions() {
			return getRuleContext(IsNullLikeInExpressionsContext.class,0);
		}
		public ExpressionExistsContext expressionExists() {
			return getRuleContext(ExpressionExistsContext.class,0);
		}
		public EqualRelationExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_equalRelationExpression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitEqualRelationExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final EqualRelationExpressionContext equalRelationExpression() throws RecognitionException {
		EqualRelationExpressionContext _localctx = new EqualRelationExpressionContext(_ctx, getState());
		enterRule(_localctx, 152, RULE_equalRelationExpression);
		try {
			setState(678);
			switch (_input.LA(1)) {
			case KW_CASE:
			case KW_CAST:
			case KW_FALSE:
			case KW_NULL:
			case KW_TRUE:
			case KW_PREVIOUS:
			case KW_OPERATOR:
			case KW_DAY:
			case KW_HOUR:
			case KW_MINUTES:
			case KW_SECONDS:
			case KW_MILLISECONDS:
			case KW_BOOLEAN:
			case KW_INT:
			case KW_LONG:
			case KW_FLOAT:
			case KW_STRING:
			case KW_TIMESTAMP:
			case KW_DATE:
			case KW_TIME:
			case KW_DECIMAL:
			case LPAREN:
			case PLUS:
			case MINUS:
			case TILDE:
			case LongLiteral:
			case FloatLiteral:
			case DoubleLiteral:
			case DecimalLiteral:
			case StringLiteral:
			case IntegerNumber:
			case Identifier:
				enterOuterAlt(_localctx, 1);
				{
				setState(676); isNullLikeInExpressions();
				}
				break;
			case KW_EXISTS:
				enterOuterAlt(_localctx, 2);
				{
				setState(677); expressionExists();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExpressionExistsContext extends ParserRuleContext {
		public TerminalNode KW_EXISTS() { return getToken(CQLParser.KW_EXISTS, 0); }
		public SubQueryExpressionContext subQueryExpression() {
			return getRuleContext(SubQueryExpressionContext.class,0);
		}
		public ExpressionExistsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expressionExists; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitExpressionExists(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionExistsContext expressionExists() throws RecognitionException {
		ExpressionExistsContext _localctx = new ExpressionExistsContext(_ctx, getState());
		enterRule(_localctx, 154, RULE_expressionExists);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(680); match(KW_EXISTS);
			setState(681); subQueryExpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class IsNullLikeInExpressionsContext extends ParserRuleContext {
		public ExpressionInContext expressionIn() {
			return getRuleContext(ExpressionInContext.class,0);
		}
		public NullConditionContext nullCondition() {
			return getRuleContext(NullConditionContext.class,0);
		}
		public ExpressionLikeContext expressionLike() {
			return getRuleContext(ExpressionLikeContext.class,0);
		}
		public BinaryExpressionContext binaryExpression() {
			return getRuleContext(BinaryExpressionContext.class,0);
		}
		public TerminalNode KW_IS() { return getToken(CQLParser.KW_IS, 0); }
		public ExpressionBetweenContext expressionBetween() {
			return getRuleContext(ExpressionBetweenContext.class,0);
		}
		public IsNullLikeInExpressionsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_isNullLikeInExpressions; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitIsNullLikeInExpressions(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IsNullLikeInExpressionsContext isNullLikeInExpressions() throws RecognitionException {
		IsNullLikeInExpressionsContext _localctx = new IsNullLikeInExpressionsContext(_ctx, getState());
		enterRule(_localctx, 156, RULE_isNullLikeInExpressions);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(683); binaryExpression();
			setState(689);
			switch ( getInterpreter().adaptivePredict(_input,56,_ctx) ) {
			case 1:
				{
				setState(684); match(KW_IS);
				setState(685); nullCondition();
				}
				break;

			case 2:
				{
				setState(686); expressionLike();
				}
				break;

			case 3:
				{
				setState(687); expressionBetween();
				}
				break;

			case 4:
				{
				setState(688); expressionIn();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BinaryExpressionContext extends ParserRuleContext {
		public RelationExpressionContext relationExpression(int i) {
			return getRuleContext(RelationExpressionContext.class,i);
		}
		public BitExpressionContext bitExpression() {
			return getRuleContext(BitExpressionContext.class,0);
		}
		public List<RelationExpressionContext> relationExpression() {
			return getRuleContexts(RelationExpressionContext.class);
		}
		public BinaryExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_binaryExpression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitBinaryExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BinaryExpressionContext binaryExpression() throws RecognitionException {
		BinaryExpressionContext _localctx = new BinaryExpressionContext(_ctx, getState());
		enterRule(_localctx, 158, RULE_binaryExpression);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(691); bitExpression();
			setState(695);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,57,_ctx);
			while ( _alt!=2 && _alt!=-1 ) {
				if ( _alt==1 ) {
					{
					{
					setState(692); relationExpression();
					}
					} 
				}
				setState(697);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,57,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExpressionLikeContext extends ParserRuleContext {
		public PrecedenceEqualNegatableOperatorContext precedenceEqualNegatableOperator() {
			return getRuleContext(PrecedenceEqualNegatableOperatorContext.class,0);
		}
		public BitExpressionContext bitExpression() {
			return getRuleContext(BitExpressionContext.class,0);
		}
		public IdentifierNotContext identifierNot() {
			return getRuleContext(IdentifierNotContext.class,0);
		}
		public ExpressionLikeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expressionLike; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitExpressionLike(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionLikeContext expressionLike() throws RecognitionException {
		ExpressionLikeContext _localctx = new ExpressionLikeContext(_ctx, getState());
		enterRule(_localctx, 160, RULE_expressionLike);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(699);
			_la = _input.LA(1);
			if (_la==KW_NOT) {
				{
				setState(698); identifierNot();
				}
			}

			setState(701); precedenceEqualNegatableOperator();
			setState(702); bitExpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PrecedenceEqualNegatableOperatorContext extends ParserRuleContext {
		public TerminalNode KW_LIKE() { return getToken(CQLParser.KW_LIKE, 0); }
		public TerminalNode KW_REGEXP() { return getToken(CQLParser.KW_REGEXP, 0); }
		public TerminalNode KW_RLIKE() { return getToken(CQLParser.KW_RLIKE, 0); }
		public PrecedenceEqualNegatableOperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_precedenceEqualNegatableOperator; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitPrecedenceEqualNegatableOperator(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PrecedenceEqualNegatableOperatorContext precedenceEqualNegatableOperator() throws RecognitionException {
		PrecedenceEqualNegatableOperatorContext _localctx = new PrecedenceEqualNegatableOperatorContext(_ctx, getState());
		enterRule(_localctx, 162, RULE_precedenceEqualNegatableOperator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(704);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << KW_LIKE) | (1L << KW_RLIKE) | (1L << KW_REGEXP))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExpressionBetweenContext extends ParserRuleContext {
		public TerminalNode KW_BETWEEN() { return getToken(CQLParser.KW_BETWEEN, 0); }
		public TerminalNode KW_AND() { return getToken(CQLParser.KW_AND, 0); }
		public ExpressionBetweenMinValueContext expressionBetweenMinValue() {
			return getRuleContext(ExpressionBetweenMinValueContext.class,0);
		}
		public ExpressionBetweenMaxValueContext expressionBetweenMaxValue() {
			return getRuleContext(ExpressionBetweenMaxValueContext.class,0);
		}
		public IdentifierNotContext identifierNot() {
			return getRuleContext(IdentifierNotContext.class,0);
		}
		public ExpressionBetweenContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expressionBetween; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitExpressionBetween(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionBetweenContext expressionBetween() throws RecognitionException {
		ExpressionBetweenContext _localctx = new ExpressionBetweenContext(_ctx, getState());
		enterRule(_localctx, 164, RULE_expressionBetween);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(707);
			_la = _input.LA(1);
			if (_la==KW_NOT) {
				{
				setState(706); identifierNot();
				}
			}

			setState(709); match(KW_BETWEEN);
			setState(710); expressionBetweenMinValue();
			setState(711); match(KW_AND);
			setState(712); expressionBetweenMaxValue();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExpressionBetweenMaxValueContext extends ParserRuleContext {
		public BitExpressionContext bitExpression() {
			return getRuleContext(BitExpressionContext.class,0);
		}
		public ExpressionBetweenMaxValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expressionBetweenMaxValue; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitExpressionBetweenMaxValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionBetweenMaxValueContext expressionBetweenMaxValue() throws RecognitionException {
		ExpressionBetweenMaxValueContext _localctx = new ExpressionBetweenMaxValueContext(_ctx, getState());
		enterRule(_localctx, 166, RULE_expressionBetweenMaxValue);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(714); bitExpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExpressionBetweenMinValueContext extends ParserRuleContext {
		public BitExpressionContext bitExpression() {
			return getRuleContext(BitExpressionContext.class,0);
		}
		public ExpressionBetweenMinValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expressionBetweenMinValue; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitExpressionBetweenMinValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionBetweenMinValueContext expressionBetweenMinValue() throws RecognitionException {
		ExpressionBetweenMinValueContext _localctx = new ExpressionBetweenMinValueContext(_ctx, getState());
		enterRule(_localctx, 168, RULE_expressionBetweenMinValue);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(716); bitExpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExpressionInContext extends ParserRuleContext {
		public TerminalNode KW_IN() { return getToken(CQLParser.KW_IN, 0); }
		public IdentifierNotContext identifierNot() {
			return getRuleContext(IdentifierNotContext.class,0);
		}
		public ExpressionsContext expressions() {
			return getRuleContext(ExpressionsContext.class,0);
		}
		public ExpressionInContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expressionIn; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitExpressionIn(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionInContext expressionIn() throws RecognitionException {
		ExpressionInContext _localctx = new ExpressionInContext(_ctx, getState());
		enterRule(_localctx, 170, RULE_expressionIn);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(719);
			_la = _input.LA(1);
			if (_la==KW_NOT) {
				{
				setState(718); identifierNot();
				}
			}

			setState(721); match(KW_IN);
			setState(722); expressions();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExpressionsContext extends ParserRuleContext {
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(CQLParser.COMMA); }
		public TerminalNode RPAREN() { return getToken(CQLParser.RPAREN, 0); }
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public TerminalNode LPAREN() { return getToken(CQLParser.LPAREN, 0); }
		public TerminalNode COMMA(int i) {
			return getToken(CQLParser.COMMA, i);
		}
		public ExpressionsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expressions; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitExpressions(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionsContext expressions() throws RecognitionException {
		ExpressionsContext _localctx = new ExpressionsContext(_ctx, getState());
		enterRule(_localctx, 172, RULE_expressions);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(724); match(LPAREN);
			setState(725); expression();
			setState(730);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(726); match(COMMA);
				setState(727); expression();
				}
				}
				setState(732);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(733); match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SubQueryExpressionContext extends ParserRuleContext {
		public TerminalNode RPAREN() { return getToken(CQLParser.RPAREN, 0); }
		public SelectStatementContext selectStatement() {
			return getRuleContext(SelectStatementContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(CQLParser.LPAREN, 0); }
		public SubQueryExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_subQueryExpression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSubQueryExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SubQueryExpressionContext subQueryExpression() throws RecognitionException {
		SubQueryExpressionContext _localctx = new SubQueryExpressionContext(_ctx, getState());
		enterRule(_localctx, 174, RULE_subQueryExpression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(735); match(LPAREN);
			setState(736); selectStatement();
			setState(737); match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RelationExpressionContext extends ParserRuleContext {
		public RelationOperatorContext relationOperator() {
			return getRuleContext(RelationOperatorContext.class,0);
		}
		public BitExpressionContext bitExpression() {
			return getRuleContext(BitExpressionContext.class,0);
		}
		public RelationExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_relationExpression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitRelationExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RelationExpressionContext relationExpression() throws RecognitionException {
		RelationExpressionContext _localctx = new RelationExpressionContext(_ctx, getState());
		enterRule(_localctx, 176, RULE_relationExpression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(739); relationOperator();
			setState(740); bitExpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RelationOperatorContext extends ParserRuleContext {
		public TerminalNode LESSTHAN() { return getToken(CQLParser.LESSTHAN, 0); }
		public TerminalNode GREATERTHANOREQUALTO() { return getToken(CQLParser.GREATERTHANOREQUALTO, 0); }
		public TerminalNode LESSTHANOREQUALTO(int i) {
			return getToken(CQLParser.LESSTHANOREQUALTO, i);
		}
		public TerminalNode GREATERTHAN() { return getToken(CQLParser.GREATERTHAN, 0); }
		public List<TerminalNode> LESSTHANOREQUALTO() { return getTokens(CQLParser.LESSTHANOREQUALTO); }
		public TerminalNode EQUAL() { return getToken(CQLParser.EQUAL, 0); }
		public TerminalNode EQUAL_NS() { return getToken(CQLParser.EQUAL_NS, 0); }
		public TerminalNode NOTEQUAL() { return getToken(CQLParser.NOTEQUAL, 0); }
		public RelationOperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_relationOperator; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitRelationOperator(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RelationOperatorContext relationOperator() throws RecognitionException {
		RelationOperatorContext _localctx = new RelationOperatorContext(_ctx, getState());
		enterRule(_localctx, 178, RULE_relationOperator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(742);
			_la = _input.LA(1);
			if ( !(((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (EQUAL - 129)) | (1L << (EQUAL_NS - 129)) | (1L << (NOTEQUAL - 129)) | (1L << (LESSTHANOREQUALTO - 129)) | (1L << (LESSTHAN - 129)) | (1L << (GREATERTHANOREQUALTO - 129)) | (1L << (GREATERTHAN - 129)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BitExpressionContext extends ParserRuleContext {
		public List<BitOperatorContext> bitOperator() {
			return getRuleContexts(BitOperatorContext.class);
		}
		public BitOperatorContext bitOperator(int i) {
			return getRuleContext(BitOperatorContext.class,i);
		}
		public List<ArithmeticPlusMinusExpressionContext> arithmeticPlusMinusExpression() {
			return getRuleContexts(ArithmeticPlusMinusExpressionContext.class);
		}
		public ArithmeticPlusMinusExpressionContext arithmeticPlusMinusExpression(int i) {
			return getRuleContext(ArithmeticPlusMinusExpressionContext.class,i);
		}
		public BitExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_bitExpression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitBitExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BitExpressionContext bitExpression() throws RecognitionException {
		BitExpressionContext _localctx = new BitExpressionContext(_ctx, getState());
		enterRule(_localctx, 180, RULE_bitExpression);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(744); arithmeticPlusMinusExpression();
			setState(750);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,62,_ctx);
			while ( _alt!=2 && _alt!=-1 ) {
				if ( _alt==1 ) {
					{
					{
					setState(745); bitOperator();
					setState(746); arithmeticPlusMinusExpression();
					}
					} 
				}
				setState(752);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,62,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BitOperatorContext extends ParserRuleContext {
		public TerminalNode AMPERSAND() { return getToken(CQLParser.AMPERSAND, 0); }
		public TerminalNode BITWISEXOR() { return getToken(CQLParser.BITWISEXOR, 0); }
		public TerminalNode BITWISEOR() { return getToken(CQLParser.BITWISEOR, 0); }
		public BitOperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_bitOperator; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitBitOperator(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BitOperatorContext bitOperator() throws RecognitionException {
		BitOperatorContext _localctx = new BitOperatorContext(_ctx, getState());
		enterRule(_localctx, 182, RULE_bitOperator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(753);
			_la = _input.LA(1);
			if ( !(((((_la - 144)) & ~0x3f) == 0 && ((1L << (_la - 144)) & ((1L << (BITWISEOR - 144)) | (1L << (AMPERSAND - 144)) | (1L << (BITWISEXOR - 144)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ArithmeticPlusMinusExpressionContext extends ParserRuleContext {
		public List<ArithmeticPlusOperatorContext> arithmeticPlusOperator() {
			return getRuleContexts(ArithmeticPlusOperatorContext.class);
		}
		public List<ArithmeticStarExpressionContext> arithmeticStarExpression() {
			return getRuleContexts(ArithmeticStarExpressionContext.class);
		}
		public ArithmeticPlusOperatorContext arithmeticPlusOperator(int i) {
			return getRuleContext(ArithmeticPlusOperatorContext.class,i);
		}
		public ArithmeticStarExpressionContext arithmeticStarExpression(int i) {
			return getRuleContext(ArithmeticStarExpressionContext.class,i);
		}
		public ArithmeticPlusMinusExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_arithmeticPlusMinusExpression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitArithmeticPlusMinusExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ArithmeticPlusMinusExpressionContext arithmeticPlusMinusExpression() throws RecognitionException {
		ArithmeticPlusMinusExpressionContext _localctx = new ArithmeticPlusMinusExpressionContext(_ctx, getState());
		enterRule(_localctx, 184, RULE_arithmeticPlusMinusExpression);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(755); arithmeticStarExpression();
			setState(761);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,63,_ctx);
			while ( _alt!=2 && _alt!=-1 ) {
				if ( _alt==1 ) {
					{
					{
					setState(756); arithmeticPlusOperator();
					setState(757); arithmeticStarExpression();
					}
					} 
				}
				setState(763);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,63,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ArithmeticPlusOperatorContext extends ParserRuleContext {
		public TerminalNode MINUS() { return getToken(CQLParser.MINUS, 0); }
		public TerminalNode CONCATENATION() { return getToken(CQLParser.CONCATENATION, 0); }
		public TerminalNode PLUS() { return getToken(CQLParser.PLUS, 0); }
		public ArithmeticPlusOperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_arithmeticPlusOperator; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitArithmeticPlusOperator(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ArithmeticPlusOperatorContext arithmeticPlusOperator() throws RecognitionException {
		ArithmeticPlusOperatorContext _localctx = new ArithmeticPlusOperatorContext(_ctx, getState());
		enterRule(_localctx, 186, RULE_arithmeticPlusOperator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(764);
			_la = _input.LA(1);
			if ( !(((((_la - 137)) & ~0x3f) == 0 && ((1L << (_la - 137)) & ((1L << (PLUS - 137)) | (1L << (MINUS - 137)) | (1L << (CONCATENATION - 137)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ArithmeticStarExpressionContext extends ParserRuleContext {
		public FieldExpressionContext fieldExpression(int i) {
			return getRuleContext(FieldExpressionContext.class,i);
		}
		public List<ArithmeticStarOperatorContext> arithmeticStarOperator() {
			return getRuleContexts(ArithmeticStarOperatorContext.class);
		}
		public ArithmeticStarOperatorContext arithmeticStarOperator(int i) {
			return getRuleContext(ArithmeticStarOperatorContext.class,i);
		}
		public List<FieldExpressionContext> fieldExpression() {
			return getRuleContexts(FieldExpressionContext.class);
		}
		public ArithmeticStarExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_arithmeticStarExpression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitArithmeticStarExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ArithmeticStarExpressionContext arithmeticStarExpression() throws RecognitionException {
		ArithmeticStarExpressionContext _localctx = new ArithmeticStarExpressionContext(_ctx, getState());
		enterRule(_localctx, 188, RULE_arithmeticStarExpression);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(766); fieldExpression();
			setState(772);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,64,_ctx);
			while ( _alt!=2 && _alt!=-1 ) {
				if ( _alt==1 ) {
					{
					{
					setState(767); arithmeticStarOperator();
					setState(768); fieldExpression();
					}
					} 
				}
				setState(774);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,64,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ArithmeticStarOperatorContext extends ParserRuleContext {
		public TerminalNode DIV() { return getToken(CQLParser.DIV, 0); }
		public TerminalNode STAR() { return getToken(CQLParser.STAR, 0); }
		public TerminalNode DIVIDE() { return getToken(CQLParser.DIVIDE, 0); }
		public TerminalNode MOD() { return getToken(CQLParser.MOD, 0); }
		public ArithmeticStarOperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_arithmeticStarOperator; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitArithmeticStarOperator(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ArithmeticStarOperatorContext arithmeticStarOperator() throws RecognitionException {
		ArithmeticStarOperatorContext _localctx = new ArithmeticStarOperatorContext(_ctx, getState());
		enterRule(_localctx, 190, RULE_arithmeticStarOperator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(775);
			_la = _input.LA(1);
			if ( !(((((_la - 136)) & ~0x3f) == 0 && ((1L << (_la - 136)) & ((1L << (DIVIDE - 136)) | (1L << (STAR - 136)) | (1L << (MOD - 136)) | (1L << (DIV - 136)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FieldExpressionContext extends ParserRuleContext {
		public TerminalNode DOT() { return getToken(CQLParser.DOT, 0); }
		public AtomExpressionContext atomExpression() {
			return getRuleContext(AtomExpressionContext.class,0);
		}
		public StreamNameOrAliasContext streamNameOrAlias() {
			return getRuleContext(StreamNameOrAliasContext.class,0);
		}
		public FieldExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fieldExpression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitFieldExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FieldExpressionContext fieldExpression() throws RecognitionException {
		FieldExpressionContext _localctx = new FieldExpressionContext(_ctx, getState());
		enterRule(_localctx, 192, RULE_fieldExpression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(780);
			switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
			case 1:
				{
				setState(777); streamNameOrAlias();
				setState(778); match(DOT);
				}
				break;
			}
			setState(782); atomExpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AtomExpressionContext extends ParserRuleContext {
		public CastExpressionContext castExpression() {
			return getRuleContext(CastExpressionContext.class,0);
		}
		public ConstNullContext constNull() {
			return getRuleContext(ConstNullContext.class,0);
		}
		public FunctionContext function() {
			return getRuleContext(FunctionContext.class,0);
		}
		public ExpressionPreviousContext expressionPrevious() {
			return getRuleContext(ExpressionPreviousContext.class,0);
		}
		public ColumnNameContext columnName() {
			return getRuleContext(ColumnNameContext.class,0);
		}
		public WhenExpressionContext whenExpression() {
			return getRuleContext(WhenExpressionContext.class,0);
		}
		public CaseExpressionContext caseExpression() {
			return getRuleContext(CaseExpressionContext.class,0);
		}
		public ConstantContext constant() {
			return getRuleContext(ConstantContext.class,0);
		}
		public ExpressionWithLaparenContext expressionWithLaparen() {
			return getRuleContext(ExpressionWithLaparenContext.class,0);
		}
		public AtomExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_atomExpression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitAtomExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AtomExpressionContext atomExpression() throws RecognitionException {
		AtomExpressionContext _localctx = new AtomExpressionContext(_ctx, getState());
		enterRule(_localctx, 194, RULE_atomExpression);
		try {
			setState(793);
			switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(784); constNull();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(785); constant();
				}
				break;

			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(786); expressionPrevious();
				}
				break;

			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(787); function();
				}
				break;

			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(788); castExpression();
				}
				break;

			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(789); caseExpression();
				}
				break;

			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(790); whenExpression();
				}
				break;

			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(791); columnName();
				}
				break;

			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(792); expressionWithLaparen();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExpressionWithLaparenContext extends ParserRuleContext {
		public TerminalNode RPAREN() { return getToken(CQLParser.RPAREN, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(CQLParser.LPAREN, 0); }
		public ExpressionWithLaparenContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expressionWithLaparen; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitExpressionWithLaparen(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionWithLaparenContext expressionWithLaparen() throws RecognitionException {
		ExpressionWithLaparenContext _localctx = new ExpressionWithLaparenContext(_ctx, getState());
		enterRule(_localctx, 196, RULE_expressionWithLaparen);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(795); match(LPAREN);
			setState(796); expression();
			setState(797); match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class WhenExpressionContext extends ParserRuleContext {
		public List<CaseWhenBodyThenBodyContext> caseWhenBodyThenBody() {
			return getRuleContexts(CaseWhenBodyThenBodyContext.class);
		}
		public List<CaseWhenBodyWhenBodyContext> caseWhenBodyWhenBody() {
			return getRuleContexts(CaseWhenBodyWhenBodyContext.class);
		}
		public CaseWhenBodyThenBodyContext caseWhenBodyThenBody(int i) {
			return getRuleContext(CaseWhenBodyThenBodyContext.class,i);
		}
		public TerminalNode KW_CASE() { return getToken(CQLParser.KW_CASE, 0); }
		public CaseWhenElseContext caseWhenElse() {
			return getRuleContext(CaseWhenElseContext.class,0);
		}
		public CaseWhenBodyWhenBodyContext caseWhenBodyWhenBody(int i) {
			return getRuleContext(CaseWhenBodyWhenBodyContext.class,i);
		}
		public TerminalNode KW_END() { return getToken(CQLParser.KW_END, 0); }
		public WhenExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_whenExpression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitWhenExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final WhenExpressionContext whenExpression() throws RecognitionException {
		WhenExpressionContext _localctx = new WhenExpressionContext(_ctx, getState());
		enterRule(_localctx, 198, RULE_whenExpression);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(799); match(KW_CASE);
			setState(803); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(800); caseWhenBodyWhenBody();
				setState(801); caseWhenBodyThenBody();
				}
				}
				setState(805); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==KW_WHEN );
			setState(808);
			_la = _input.LA(1);
			if (_la==KW_ELSE) {
				{
				setState(807); caseWhenElse();
				}
			}

			setState(810); match(KW_END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CaseExpressionContext extends ParserRuleContext {
		public List<CaseWhenBodyThenBodyContext> caseWhenBodyThenBody() {
			return getRuleContexts(CaseWhenBodyThenBodyContext.class);
		}
		public List<CaseWhenBodyWhenBodyContext> caseWhenBodyWhenBody() {
			return getRuleContexts(CaseWhenBodyWhenBodyContext.class);
		}
		public CaseWhenBodyThenBodyContext caseWhenBodyThenBody(int i) {
			return getRuleContext(CaseWhenBodyThenBodyContext.class,i);
		}
		public TerminalNode KW_CASE() { return getToken(CQLParser.KW_CASE, 0); }
		public CaseWhenElseContext caseWhenElse() {
			return getRuleContext(CaseWhenElseContext.class,0);
		}
		public CaseHeadExpressionContext caseHeadExpression() {
			return getRuleContext(CaseHeadExpressionContext.class,0);
		}
		public CaseWhenBodyWhenBodyContext caseWhenBodyWhenBody(int i) {
			return getRuleContext(CaseWhenBodyWhenBodyContext.class,i);
		}
		public TerminalNode KW_END() { return getToken(CQLParser.KW_END, 0); }
		public CaseExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_caseExpression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitCaseExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CaseExpressionContext caseExpression() throws RecognitionException {
		CaseExpressionContext _localctx = new CaseExpressionContext(_ctx, getState());
		enterRule(_localctx, 200, RULE_caseExpression);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(812); match(KW_CASE);
			setState(813); caseHeadExpression();
			setState(817); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(814); caseWhenBodyWhenBody();
				setState(815); caseWhenBodyThenBody();
				}
				}
				setState(819); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==KW_WHEN );
			setState(822);
			_la = _input.LA(1);
			if (_la==KW_ELSE) {
				{
				setState(821); caseWhenElse();
				}
			}

			setState(824); match(KW_END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CaseWhenElseContext extends ParserRuleContext {
		public TerminalNode KW_ELSE() { return getToken(CQLParser.KW_ELSE, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public CaseWhenElseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_caseWhenElse; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitCaseWhenElse(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CaseWhenElseContext caseWhenElse() throws RecognitionException {
		CaseWhenElseContext _localctx = new CaseWhenElseContext(_ctx, getState());
		enterRule(_localctx, 202, RULE_caseWhenElse);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(826); match(KW_ELSE);
			setState(827); expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CaseWhenBodyThenBodyContext extends ParserRuleContext {
		public TerminalNode KW_THEN() { return getToken(CQLParser.KW_THEN, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public CaseWhenBodyThenBodyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_caseWhenBodyThenBody; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitCaseWhenBodyThenBody(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CaseWhenBodyThenBodyContext caseWhenBodyThenBody() throws RecognitionException {
		CaseWhenBodyThenBodyContext _localctx = new CaseWhenBodyThenBodyContext(_ctx, getState());
		enterRule(_localctx, 204, RULE_caseWhenBodyThenBody);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(829); match(KW_THEN);
			setState(830); expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CaseWhenBodyWhenBodyContext extends ParserRuleContext {
		public TerminalNode KW_WHEN() { return getToken(CQLParser.KW_WHEN, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public CaseWhenBodyWhenBodyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_caseWhenBodyWhenBody; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitCaseWhenBodyWhenBody(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CaseWhenBodyWhenBodyContext caseWhenBodyWhenBody() throws RecognitionException {
		CaseWhenBodyWhenBodyContext _localctx = new CaseWhenBodyWhenBodyContext(_ctx, getState());
		enterRule(_localctx, 206, RULE_caseWhenBodyWhenBody);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(832); match(KW_WHEN);
			setState(833); expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CaseHeadExpressionContext extends ParserRuleContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public CaseHeadExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_caseHeadExpression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitCaseHeadExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CaseHeadExpressionContext caseHeadExpression() throws RecognitionException {
		CaseHeadExpressionContext _localctx = new CaseHeadExpressionContext(_ctx, getState());
		enterRule(_localctx, 208, RULE_caseHeadExpression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(835); expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CastExpressionContext extends ParserRuleContext {
		public TerminalNode KW_AS() { return getToken(CQLParser.KW_AS, 0); }
		public TerminalNode KW_CAST() { return getToken(CQLParser.KW_CAST, 0); }
		public TerminalNode RPAREN() { return getToken(CQLParser.RPAREN, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(CQLParser.LPAREN, 0); }
		public PrimitiveTypeContext primitiveType() {
			return getRuleContext(PrimitiveTypeContext.class,0);
		}
		public CastExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_castExpression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitCastExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CastExpressionContext castExpression() throws RecognitionException {
		CastExpressionContext _localctx = new CastExpressionContext(_ctx, getState());
		enterRule(_localctx, 210, RULE_castExpression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(837); match(KW_CAST);
			setState(838); match(LPAREN);
			setState(839); expression();
			setState(840); match(KW_AS);
			setState(841); primitiveType();
			setState(842); match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FunctionContext extends ParserRuleContext {
		public DistinctContext distinct() {
			return getRuleContext(DistinctContext.class,0);
		}
		public SelectExpressionContext selectExpression(int i) {
			return getRuleContext(SelectExpressionContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(CQLParser.COMMA); }
		public TerminalNode RPAREN() { return getToken(CQLParser.RPAREN, 0); }
		public List<SelectExpressionContext> selectExpression() {
			return getRuleContexts(SelectExpressionContext.class);
		}
		public TerminalNode LPAREN() { return getToken(CQLParser.LPAREN, 0); }
		public FunctionNameContext functionName() {
			return getRuleContext(FunctionNameContext.class,0);
		}
		public TerminalNode COMMA(int i) {
			return getToken(CQLParser.COMMA, i);
		}
		public FunctionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_function; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitFunction(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FunctionContext function() throws RecognitionException {
		FunctionContext _localctx = new FunctionContext(_ctx, getState());
		enterRule(_localctx, 212, RULE_function);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(844); functionName();
			setState(845); match(LPAREN);
			setState(847);
			_la = _input.LA(1);
			if (_la==KW_DISTINCT) {
				{
				setState(846); distinct();
				}
			}

			setState(857);
			_la = _input.LA(1);
			if (((((_la - 31)) & ~0x3f) == 0 && ((1L << (_la - 31)) & ((1L << (KW_CASE - 31)) | (1L << (KW_CAST - 31)) | (1L << (KW_EXISTS - 31)) | (1L << (KW_FALSE - 31)) | (1L << (KW_NULL - 31)) | (1L << (KW_TRUE - 31)) | (1L << (KW_NOT - 31)) | (1L << (KW_PREVIOUS - 31)))) != 0) || ((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & ((1L << (KW_OPERATOR - 101)) | (1L << (KW_DAY - 101)) | (1L << (KW_HOUR - 101)) | (1L << (KW_MINUTES - 101)) | (1L << (KW_SECONDS - 101)) | (1L << (KW_MILLISECONDS - 101)) | (1L << (KW_BOOLEAN - 101)) | (1L << (KW_INT - 101)) | (1L << (KW_LONG - 101)) | (1L << (KW_FLOAT - 101)) | (1L << (KW_STRING - 101)) | (1L << (KW_TIMESTAMP - 101)) | (1L << (KW_DATE - 101)) | (1L << (KW_TIME - 101)) | (1L << (KW_DECIMAL - 101)) | (1L << (LPAREN - 101)) | (1L << (PLUS - 101)) | (1L << (MINUS - 101)) | (1L << (STAR - 101)) | (1L << (TILDE - 101)) | (1L << (LongLiteral - 101)) | (1L << (FloatLiteral - 101)) | (1L << (DoubleLiteral - 101)) | (1L << (DecimalLiteral - 101)) | (1L << (StringLiteral - 101)) | (1L << (IntegerNumber - 101)) | (1L << (Identifier - 101)))) != 0)) {
				{
				setState(849); selectExpression();
				setState(854);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(850); match(COMMA);
					setState(851); selectExpression();
					}
					}
					setState(856);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
			}

			setState(859); match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExpressionPreviousContext extends ParserRuleContext {
		public TerminalNode KW_PREVIOUS() { return getToken(CQLParser.KW_PREVIOUS, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public ExpressionPreviousContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expressionPrevious; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitExpressionPrevious(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionPreviousContext expressionPrevious() throws RecognitionException {
		ExpressionPreviousContext _localctx = new ExpressionPreviousContext(_ctx, getState());
		enterRule(_localctx, 214, RULE_expressionPrevious);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(861); match(KW_PREVIOUS);
			setState(862); expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ConstantContext extends ParserRuleContext {
		public BooleanValueContext booleanValue() {
			return getRuleContext(BooleanValueContext.class,0);
		}
		public ConstDoubleValueContext constDoubleValue() {
			return getRuleContext(ConstDoubleValueContext.class,0);
		}
		public UnaryOperatorContext unaryOperator() {
			return getRuleContext(UnaryOperatorContext.class,0);
		}
		public ConstBigDecimalValueContext constBigDecimalValue() {
			return getRuleContext(ConstBigDecimalValueContext.class,0);
		}
		public ConstStingValueContext constStingValue() {
			return getRuleContext(ConstStingValueContext.class,0);
		}
		public ConstLongValueContext constLongValue() {
			return getRuleContext(ConstLongValueContext.class,0);
		}
		public ConstIntegerValueContext constIntegerValue() {
			return getRuleContext(ConstIntegerValueContext.class,0);
		}
		public ConstFloatValueContext constFloatValue() {
			return getRuleContext(ConstFloatValueContext.class,0);
		}
		public ConstantContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_constant; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitConstant(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConstantContext constant() throws RecognitionException {
		ConstantContext _localctx = new ConstantContext(_ctx, getState());
		enterRule(_localctx, 216, RULE_constant);
		int _la;
		try {
			setState(876);
			switch (_input.LA(1)) {
			case PLUS:
			case MINUS:
			case TILDE:
			case LongLiteral:
			case FloatLiteral:
			case DoubleLiteral:
			case DecimalLiteral:
			case IntegerNumber:
				enterOuterAlt(_localctx, 1);
				{
				setState(865);
				_la = _input.LA(1);
				if (((((_la - 137)) & ~0x3f) == 0 && ((1L << (_la - 137)) & ((1L << (PLUS - 137)) | (1L << (MINUS - 137)) | (1L << (TILDE - 137)))) != 0)) {
					{
					setState(864); unaryOperator();
					}
				}

				setState(872);
				switch (_input.LA(1)) {
				case IntegerNumber:
					{
					setState(867); constIntegerValue();
					}
					break;
				case LongLiteral:
					{
					setState(868); constLongValue();
					}
					break;
				case FloatLiteral:
					{
					setState(869); constFloatValue();
					}
					break;
				case DoubleLiteral:
					{
					setState(870); constDoubleValue();
					}
					break;
				case DecimalLiteral:
					{
					setState(871); constBigDecimalValue();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;
			case StringLiteral:
				enterOuterAlt(_localctx, 2);
				{
				setState(874); constStingValue();
				}
				break;
			case KW_FALSE:
			case KW_TRUE:
				enterOuterAlt(_localctx, 3);
				{
				setState(875); booleanValue();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BooleanValueContext extends ParserRuleContext {
		public TerminalNode KW_FALSE() { return getToken(CQLParser.KW_FALSE, 0); }
		public TerminalNode KW_TRUE() { return getToken(CQLParser.KW_TRUE, 0); }
		public BooleanValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_booleanValue; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitBooleanValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BooleanValueContext booleanValue() throws RecognitionException {
		BooleanValueContext _localctx = new BooleanValueContext(_ctx, getState());
		enterRule(_localctx, 218, RULE_booleanValue);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(878);
			_la = _input.LA(1);
			if ( !(_la==KW_FALSE || _la==KW_TRUE) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ConstStingValueContext extends ParserRuleContext {
		public TerminalNode StringLiteral() { return getToken(CQLParser.StringLiteral, 0); }
		public ConstStingValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_constStingValue; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitConstStingValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConstStingValueContext constStingValue() throws RecognitionException {
		ConstStingValueContext _localctx = new ConstStingValueContext(_ctx, getState());
		enterRule(_localctx, 220, RULE_constStingValue);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(880); match(StringLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ConstIntegerValueContext extends ParserRuleContext {
		public TerminalNode IntegerNumber() { return getToken(CQLParser.IntegerNumber, 0); }
		public ConstIntegerValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_constIntegerValue; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitConstIntegerValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConstIntegerValueContext constIntegerValue() throws RecognitionException {
		ConstIntegerValueContext _localctx = new ConstIntegerValueContext(_ctx, getState());
		enterRule(_localctx, 222, RULE_constIntegerValue);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(882); match(IntegerNumber);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ConstBigDecimalValueContext extends ParserRuleContext {
		public TerminalNode DecimalLiteral() { return getToken(CQLParser.DecimalLiteral, 0); }
		public ConstBigDecimalValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_constBigDecimalValue; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitConstBigDecimalValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConstBigDecimalValueContext constBigDecimalValue() throws RecognitionException {
		ConstBigDecimalValueContext _localctx = new ConstBigDecimalValueContext(_ctx, getState());
		enterRule(_localctx, 224, RULE_constBigDecimalValue);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(884); match(DecimalLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ConstDoubleValueContext extends ParserRuleContext {
		public TerminalNode DoubleLiteral() { return getToken(CQLParser.DoubleLiteral, 0); }
		public ConstDoubleValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_constDoubleValue; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitConstDoubleValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConstDoubleValueContext constDoubleValue() throws RecognitionException {
		ConstDoubleValueContext _localctx = new ConstDoubleValueContext(_ctx, getState());
		enterRule(_localctx, 226, RULE_constDoubleValue);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(886); match(DoubleLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ConstFloatValueContext extends ParserRuleContext {
		public TerminalNode FloatLiteral() { return getToken(CQLParser.FloatLiteral, 0); }
		public ConstFloatValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_constFloatValue; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitConstFloatValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConstFloatValueContext constFloatValue() throws RecognitionException {
		ConstFloatValueContext _localctx = new ConstFloatValueContext(_ctx, getState());
		enterRule(_localctx, 228, RULE_constFloatValue);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(888); match(FloatLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ConstLongValueContext extends ParserRuleContext {
		public TerminalNode LongLiteral() { return getToken(CQLParser.LongLiteral, 0); }
		public ConstLongValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_constLongValue; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitConstLongValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConstLongValueContext constLongValue() throws RecognitionException {
		ConstLongValueContext _localctx = new ConstLongValueContext(_ctx, getState());
		enterRule(_localctx, 230, RULE_constLongValue);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(890); match(LongLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SubmitApplicationContext extends ParserRuleContext {
		public PathContext path() {
			return getRuleContext(PathContext.class,0);
		}
		public ApplicationNameContext applicationName() {
			return getRuleContext(ApplicationNameContext.class,0);
		}
		public TerminalNode KW_SUBMIT() { return getToken(CQLParser.KW_SUBMIT, 0); }
		public TerminalNode KW_APPLICATION() { return getToken(CQLParser.KW_APPLICATION, 0); }
		public IsForceContext isForce() {
			return getRuleContext(IsForceContext.class,0);
		}
		public SubmitApplicationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_submitApplication; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitSubmitApplication(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SubmitApplicationContext submitApplication() throws RecognitionException {
		SubmitApplicationContext _localctx = new SubmitApplicationContext(_ctx, getState());
		enterRule(_localctx, 232, RULE_submitApplication);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(892); match(KW_SUBMIT);
			setState(893); match(KW_APPLICATION);
			setState(895);
			_la = _input.LA(1);
			if (_la==KW_FORCE) {
				{
				setState(894); isForce();
				}
			}

			setState(898);
			_la = _input.LA(1);
			if (((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & ((1L << (KW_OPERATOR - 101)) | (1L << (KW_DAY - 101)) | (1L << (KW_HOUR - 101)) | (1L << (KW_MINUTES - 101)) | (1L << (KW_SECONDS - 101)) | (1L << (KW_MILLISECONDS - 101)) | (1L << (KW_BOOLEAN - 101)) | (1L << (KW_INT - 101)) | (1L << (KW_LONG - 101)) | (1L << (KW_FLOAT - 101)) | (1L << (KW_STRING - 101)) | (1L << (KW_TIMESTAMP - 101)) | (1L << (KW_DATE - 101)) | (1L << (KW_TIME - 101)) | (1L << (KW_DECIMAL - 101)) | (1L << (IntegerNumber - 101)) | (1L << (Identifier - 101)))) != 0)) {
				{
				setState(897); applicationName();
				}
			}

			setState(901);
			_la = _input.LA(1);
			if (_la==StringLiteral) {
				{
				setState(900); path();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CqlIdentifierContext extends ParserRuleContext {
		public TerminalNode KW_MINUTES() { return getToken(CQLParser.KW_MINUTES, 0); }
		public TerminalNode KW_SECONDS() { return getToken(CQLParser.KW_SECONDS, 0); }
		public TerminalNode KW_TIMESTAMP() { return getToken(CQLParser.KW_TIMESTAMP, 0); }
		public TerminalNode Identifier() { return getToken(CQLParser.Identifier, 0); }
		public TerminalNode KW_TIME() { return getToken(CQLParser.KW_TIME, 0); }
		public TerminalNode KW_INT() { return getToken(CQLParser.KW_INT, 0); }
		public TerminalNode KW_HOUR() { return getToken(CQLParser.KW_HOUR, 0); }
		public TerminalNode KW_DECIMAL() { return getToken(CQLParser.KW_DECIMAL, 0); }
		public TerminalNode KW_DAY() { return getToken(CQLParser.KW_DAY, 0); }
		public TerminalNode KW_MILLISECONDS() { return getToken(CQLParser.KW_MILLISECONDS, 0); }
		public TerminalNode KW_BOOLEAN() { return getToken(CQLParser.KW_BOOLEAN, 0); }
		public TerminalNode KW_OPERATOR() { return getToken(CQLParser.KW_OPERATOR, 0); }
		public TerminalNode KW_FLOAT() { return getToken(CQLParser.KW_FLOAT, 0); }
		public TerminalNode KW_LONG() { return getToken(CQLParser.KW_LONG, 0); }
		public TerminalNode KW_STRING() { return getToken(CQLParser.KW_STRING, 0); }
		public TerminalNode KW_DATE() { return getToken(CQLParser.KW_DATE, 0); }
		public CqlIdentifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cqlIdentifier; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitCqlIdentifier(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CqlIdentifierContext cqlIdentifier() throws RecognitionException {
		CqlIdentifierContext _localctx = new CqlIdentifierContext(_ctx, getState());
		enterRule(_localctx, 234, RULE_cqlIdentifier);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(903);
			_la = _input.LA(1);
			if ( !(((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & ((1L << (KW_OPERATOR - 101)) | (1L << (KW_DAY - 101)) | (1L << (KW_HOUR - 101)) | (1L << (KW_MINUTES - 101)) | (1L << (KW_SECONDS - 101)) | (1L << (KW_MILLISECONDS - 101)) | (1L << (KW_BOOLEAN - 101)) | (1L << (KW_INT - 101)) | (1L << (KW_LONG - 101)) | (1L << (KW_FLOAT - 101)) | (1L << (KW_STRING - 101)) | (1L << (KW_TIMESTAMP - 101)) | (1L << (KW_DATE - 101)) | (1L << (KW_TIME - 101)) | (1L << (KW_DECIMAL - 101)) | (1L << (Identifier - 101)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class StreamPropertiesContext extends ParserRuleContext {
		public TerminalNode RPAREN() { return getToken(CQLParser.RPAREN, 0); }
		public TerminalNode KW_PROPERTIES() { return getToken(CQLParser.KW_PROPERTIES, 0); }
		public StreamPropertiesListContext streamPropertiesList() {
			return getRuleContext(StreamPropertiesListContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(CQLParser.LPAREN, 0); }
		public StreamPropertiesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_streamProperties; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitStreamProperties(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StreamPropertiesContext streamProperties() throws RecognitionException {
		StreamPropertiesContext _localctx = new StreamPropertiesContext(_ctx, getState());
		enterRule(_localctx, 236, RULE_streamProperties);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(905); match(KW_PROPERTIES);
			setState(906); match(LPAREN);
			setState(907); streamPropertiesList();
			setState(908); match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ConfNameContext extends ParserRuleContext {
		public TerminalNode StringLiteral() { return getToken(CQLParser.StringLiteral, 0); }
		public ConfNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_confName; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitConfName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConfNameContext confName() throws RecognitionException {
		ConfNameContext _localctx = new ConfNameContext(_ctx, getState());
		enterRule(_localctx, 238, RULE_confName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(910); match(StringLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ConfValueContext extends ParserRuleContext {
		public TerminalNode StringLiteral() { return getToken(CQLParser.StringLiteral, 0); }
		public ConfValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_confValue; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitConfValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConfValueContext confValue() throws RecognitionException {
		ConfValueContext _localctx = new ConfValueContext(_ctx, getState());
		enterRule(_localctx, 240, RULE_confValue);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(912); match(StringLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ColumnNameContext extends ParserRuleContext {
		public CqlIdentifierContext cqlIdentifier() {
			return getRuleContext(CqlIdentifierContext.class,0);
		}
		public ColumnNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_columnName; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitColumnName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ColumnNameContext columnName() throws RecognitionException {
		ColumnNameContext _localctx = new ColumnNameContext(_ctx, getState());
		enterRule(_localctx, 242, RULE_columnName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(914); cqlIdentifier();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ClassNameContext extends ParserRuleContext {
		public InnerClassNameContext innerClassName() {
			return getRuleContext(InnerClassNameContext.class,0);
		}
		public UserDefinedClassNameContext userDefinedClassName() {
			return getRuleContext(UserDefinedClassNameContext.class,0);
		}
		public ClassNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_className; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitClassName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ClassNameContext className() throws RecognitionException {
		ClassNameContext _localctx = new ClassNameContext(_ctx, getState());
		enterRule(_localctx, 244, RULE_className);
		try {
			setState(918);
			switch (_input.LA(1)) {
			case KW_OPERATOR:
			case KW_DAY:
			case KW_HOUR:
			case KW_MINUTES:
			case KW_SECONDS:
			case KW_MILLISECONDS:
			case KW_BOOLEAN:
			case KW_INT:
			case KW_LONG:
			case KW_FLOAT:
			case KW_STRING:
			case KW_TIMESTAMP:
			case KW_DATE:
			case KW_TIME:
			case KW_DECIMAL:
			case Identifier:
				enterOuterAlt(_localctx, 1);
				{
				setState(916); innerClassName();
				}
				break;
			case StringLiteral:
				enterOuterAlt(_localctx, 2);
				{
				setState(917); userDefinedClassName();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class InnerClassNameContext extends ParserRuleContext {
		public CqlIdentifierContext cqlIdentifier() {
			return getRuleContext(CqlIdentifierContext.class,0);
		}
		public InnerClassNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_innerClassName; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitInnerClassName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final InnerClassNameContext innerClassName() throws RecognitionException {
		InnerClassNameContext _localctx = new InnerClassNameContext(_ctx, getState());
		enterRule(_localctx, 246, RULE_innerClassName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(920); cqlIdentifier();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UserDefinedClassNameContext extends ParserRuleContext {
		public TerminalNode StringLiteral() { return getToken(CQLParser.StringLiteral, 0); }
		public UserDefinedClassNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_userDefinedClassName; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitUserDefinedClassName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UserDefinedClassNameContext userDefinedClassName() throws RecognitionException {
		UserDefinedClassNameContext _localctx = new UserDefinedClassNameContext(_ctx, getState());
		enterRule(_localctx, 248, RULE_userDefinedClassName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(922); match(StringLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class StreamNameContext extends ParserRuleContext {
		public CqlIdentifierContext cqlIdentifier() {
			return getRuleContext(CqlIdentifierContext.class,0);
		}
		public StreamNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_streamName; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitStreamName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StreamNameContext streamName() throws RecognitionException {
		StreamNameContext _localctx = new StreamNameContext(_ctx, getState());
		enterRule(_localctx, 250, RULE_streamName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(924); cqlIdentifier();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ApplicationNameContext extends ParserRuleContext {
		public CqlIdentifierContext cqlIdentifier() {
			return getRuleContext(CqlIdentifierContext.class,0);
		}
		public ConstIntegerValueContext constIntegerValue() {
			return getRuleContext(ConstIntegerValueContext.class,0);
		}
		public ApplicationNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_applicationName; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitApplicationName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ApplicationNameContext applicationName() throws RecognitionException {
		ApplicationNameContext _localctx = new ApplicationNameContext(_ctx, getState());
		enterRule(_localctx, 252, RULE_applicationName);
		try {
			setState(928);
			switch (_input.LA(1)) {
			case KW_OPERATOR:
			case KW_DAY:
			case KW_HOUR:
			case KW_MINUTES:
			case KW_SECONDS:
			case KW_MILLISECONDS:
			case KW_BOOLEAN:
			case KW_INT:
			case KW_LONG:
			case KW_FLOAT:
			case KW_STRING:
			case KW_TIMESTAMP:
			case KW_DATE:
			case KW_TIME:
			case KW_DECIMAL:
			case Identifier:
				enterOuterAlt(_localctx, 1);
				{
				setState(926); cqlIdentifier();
				}
				break;
			case IntegerNumber:
				enterOuterAlt(_localctx, 2);
				{
				setState(927); constIntegerValue();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PathContext extends ParserRuleContext {
		public TerminalNode StringLiteral() { return getToken(CQLParser.StringLiteral, 0); }
		public PathContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_path; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitPath(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PathContext path() throws RecognitionException {
		PathContext _localctx = new PathContext(_ctx, getState());
		enterRule(_localctx, 254, RULE_path);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(930); match(StringLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class IsForceContext extends ParserRuleContext {
		public TerminalNode KW_FORCE() { return getToken(CQLParser.KW_FORCE, 0); }
		public IsForceContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_isForce; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitIsForce(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IsForceContext isForce() throws RecognitionException {
		IsForceContext _localctx = new IsForceContext(_ctx, getState());
		enterRule(_localctx, 256, RULE_isForce);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(932); match(KW_FORCE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ColumnALiasContext extends ParserRuleContext {
		public CqlIdentifierContext cqlIdentifier() {
			return getRuleContext(CqlIdentifierContext.class,0);
		}
		public ColumnALiasContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_columnALias; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitColumnALias(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ColumnALiasContext columnALias() throws RecognitionException {
		ColumnALiasContext _localctx = new ColumnALiasContext(_ctx, getState());
		enterRule(_localctx, 258, RULE_columnALias);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(934); cqlIdentifier();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class IdentifierNotContext extends ParserRuleContext {
		public TerminalNode KW_NOT() { return getToken(CQLParser.KW_NOT, 0); }
		public IdentifierNotContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_identifierNot; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitIdentifierNot(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IdentifierNotContext identifierNot() throws RecognitionException {
		IdentifierNotContext _localctx = new IdentifierNotContext(_ctx, getState());
		enterRule(_localctx, 260, RULE_identifierNot);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(936); match(KW_NOT);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class NullConditionContext extends ParserRuleContext {
		public TerminalNode KW_NULL() { return getToken(CQLParser.KW_NULL, 0); }
		public IdentifierNotContext identifierNot() {
			return getRuleContext(IdentifierNotContext.class,0);
		}
		public NullConditionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_nullCondition; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitNullCondition(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NullConditionContext nullCondition() throws RecognitionException {
		NullConditionContext _localctx = new NullConditionContext(_ctx, getState());
		enterRule(_localctx, 262, RULE_nullCondition);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(939);
			_la = _input.LA(1);
			if (_la==KW_NOT) {
				{
				setState(938); identifierNot();
				}
			}

			setState(941); match(KW_NULL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class StreamNameOrAliasContext extends ParserRuleContext {
		public CqlIdentifierContext cqlIdentifier() {
			return getRuleContext(CqlIdentifierContext.class,0);
		}
		public StreamNameOrAliasContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_streamNameOrAlias; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitStreamNameOrAlias(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StreamNameOrAliasContext streamNameOrAlias() throws RecognitionException {
		StreamNameOrAliasContext _localctx = new StreamNameOrAliasContext(_ctx, getState());
		enterRule(_localctx, 264, RULE_streamNameOrAlias);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(943); cqlIdentifier();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ConstNullContext extends ParserRuleContext {
		public TerminalNode KW_NULL() { return getToken(CQLParser.KW_NULL, 0); }
		public ConstNullContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_constNull; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitConstNull(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConstNullContext constNull() throws RecognitionException {
		ConstNullContext _localctx = new ConstNullContext(_ctx, getState());
		enterRule(_localctx, 266, RULE_constNull);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(945); match(KW_NULL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UnaryOperatorContext extends ParserRuleContext {
		public TerminalNode TILDE() { return getToken(CQLParser.TILDE, 0); }
		public TerminalNode MINUS() { return getToken(CQLParser.MINUS, 0); }
		public TerminalNode PLUS() { return getToken(CQLParser.PLUS, 0); }
		public UnaryOperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unaryOperator; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitUnaryOperator(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UnaryOperatorContext unaryOperator() throws RecognitionException {
		UnaryOperatorContext _localctx = new UnaryOperatorContext(_ctx, getState());
		enterRule(_localctx, 268, RULE_unaryOperator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(947);
			_la = _input.LA(1);
			if ( !(((((_la - 137)) & ~0x3f) == 0 && ((1L << (_la - 137)) & ((1L << (PLUS - 137)) | (1L << (MINUS - 137)) | (1L << (TILDE - 137)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FunctionNameContext extends ParserRuleContext {
		public CqlIdentifierContext cqlIdentifier() {
			return getRuleContext(CqlIdentifierContext.class,0);
		}
		public FunctionNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_functionName; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitFunctionName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FunctionNameContext functionName() throws RecognitionException {
		FunctionNameContext _localctx = new FunctionNameContext(_ctx, getState());
		enterRule(_localctx, 270, RULE_functionName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(949); cqlIdentifier();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DataSourceNameContext extends ParserRuleContext {
		public CqlIdentifierContext cqlIdentifier() {
			return getRuleContext(CqlIdentifierContext.class,0);
		}
		public DataSourceNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dataSourceName; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitDataSourceName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DataSourceNameContext dataSourceName() throws RecognitionException {
		DataSourceNameContext _localctx = new DataSourceNameContext(_ctx, getState());
		enterRule(_localctx, 272, RULE_dataSourceName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(951); cqlIdentifier();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class StreamAliasContext extends ParserRuleContext {
		public CqlIdentifierContext cqlIdentifier() {
			return getRuleContext(CqlIdentifierContext.class,0);
		}
		public StreamAliasContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_streamAlias; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CQLVisitor ) return ((CQLVisitor<? extends T>)visitor).visitStreamAlias(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StreamAliasContext streamAlias() throws RecognitionException {
		StreamAliasContext _localctx = new StreamAliasContext(_ctx, getState());
		enterRule(_localctx, 274, RULE_streamAlias);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(953); cqlIdentifier();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\3\uacf5\uee8c\u4f5d\u8b0d\u4a45\u78bd\u1b2f\u3378\3\u00a3\u03be\4\2\t"+
		"\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
		"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
		"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
		"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
		",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
		"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
		"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
		"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
		"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
		"`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+
		"k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+
		"w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+
		"\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+
		"\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+
		"\4\u008a\t\u008a\4\u008b\t\u008b\3\2\3\2\3\2\3\2\3\2\3\2\5\2\u011d\n\2"+
		"\3\3\3\3\5\3\u0121\n\3\3\4\3\4\3\4\5\4\u0126\n\4\3\5\3\5\3\5\3\6\3\6\3"+
		"\6\5\6\u012e\n\6\3\6\3\6\3\7\3\7\3\7\5\7\u0135\n\7\3\7\5\7\u0138\n\7\3"+
		"\7\5\7\u013b\n\7\3\7\5\7\u013e\n\7\3\7\5\7\u0141\n\7\3\7\5\7\u0144\n\7"+
		"\3\b\3\b\3\b\3\t\3\t\3\t\5\t\u014c\n\t\3\n\3\n\3\n\3\13\3\13\3\f\3\f\3"+
		"\f\3\f\3\r\3\r\3\r\7\r\u015a\n\r\f\r\16\r\u015d\13\r\3\16\3\16\3\17\3"+
		"\17\3\17\3\20\3\20\3\21\3\21\3\21\3\21\3\22\3\22\3\22\7\22\u016d\n\22"+
		"\f\22\16\22\u0170\13\22\3\23\3\23\5\23\u0174\n\23\3\24\3\24\3\25\3\25"+
		"\3\25\3\26\3\26\3\27\3\27\3\27\3\27\3\27\6\27\u0182\n\27\r\27\16\27\u0183"+
		"\3\27\3\27\3\30\5\30\u0189\n\30\3\30\3\30\3\31\3\31\3\32\3\32\3\32\7\32"+
		"\u0192\n\32\f\32\16\32\u0195\13\32\3\33\3\33\3\34\3\34\5\34\u019b\n\34"+
		"\3\34\5\34\u019e\n\34\3\35\3\35\5\35\u01a2\n\35\3\36\3\36\3\36\3\36\3"+
		"\36\7\36\u01a9\n\36\f\36\16\36\u01ac\13\36\3\36\3\36\3\37\5\37\u01b1\n"+
		"\37\3\37\3\37\3 \3 \3 \5 \u01b8\n \3 \3 \3!\3!\7!\u01be\n!\f!\16!\u01c1"+
		"\13!\3\"\3\"\3\"\5\"\u01c6\n\"\3#\3#\3#\3$\3$\5$\u01cd\n$\3%\3%\3%\3%"+
		"\5%\u01d3\n%\3&\3&\3&\3&\3&\3&\3\'\3\'\3\'\5\'\u01de\n\'\3\'\3\'\3(\3"+
		"(\3(\7(\u01e5\n(\f(\16(\u01e8\13(\3)\3)\3)\3)\3)\3*\3*\3*\3*\3*\3*\5*"+
		"\u01f5\n*\3+\3+\3+\3,\3,\3,\5,\u01fd\n,\3-\3-\5-\u0201\n-\3-\3-\3.\3."+
		"\5.\u0207\n.\3.\3.\3/\3/\5/\u020d\n/\3/\3/\3\60\3\60\3\60\5\60\u0214\n"+
		"\60\3\61\3\61\3\61\3\61\3\62\3\62\5\62\u021c\n\62\3\62\5\62\u021f\n\62"+
		"\3\63\3\63\3\64\5\64\u0224\n\64\3\64\3\64\3\65\3\65\5\65\u022a\n\65\3"+
		"\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\5\66\u0234\n\66\3\66\5\66\u0237"+
		"\n\66\3\66\5\66\u023a\n\66\3\66\3\66\5\66\u023e\n\66\3\67\3\67\3\67\3"+
		"\67\3\67\3\67\3\67\3\67\5\67\u0248\n\67\3\67\5\67\u024b\n\67\3\67\5\67"+
		"\u024e\n\67\3\67\3\67\5\67\u0252\n\67\38\38\38\78\u0257\n8\f8\168\u025a"+
		"\138\39\39\59\u025e\n9\3:\3:\3:\3;\3;\3<\3<\5<\u0267\n<\3=\3=\3=\3>\3"+
		">\3?\3?\5?\u0270\n?\3@\3@\3@\3A\3A\3B\3B\3B\3C\3C\3D\3D\3E\3E\3E\5E\u0281"+
		"\nE\3F\3F\3F\3G\3G\3H\3H\3H\7H\u028b\nH\fH\16H\u028e\13H\3I\3I\3I\3I\3"+
		"J\3J\3K\3K\3K\7K\u0299\nK\fK\16K\u029c\13K\3L\3L\3L\3L\3M\5M\u02a3\nM"+
		"\3M\3M\3N\3N\5N\u02a9\nN\3O\3O\3O\3P\3P\3P\3P\3P\3P\5P\u02b4\nP\3Q\3Q"+
		"\7Q\u02b8\nQ\fQ\16Q\u02bb\13Q\3R\5R\u02be\nR\3R\3R\3R\3S\3S\3T\5T\u02c6"+
		"\nT\3T\3T\3T\3T\3T\3U\3U\3V\3V\3W\5W\u02d2\nW\3W\3W\3W\3X\3X\3X\3X\7X"+
		"\u02db\nX\fX\16X\u02de\13X\3X\3X\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3[\3[\3\\\3\\\3"+
		"\\\3\\\7\\\u02ef\n\\\f\\\16\\\u02f2\13\\\3]\3]\3^\3^\3^\3^\7^\u02fa\n"+
		"^\f^\16^\u02fd\13^\3_\3_\3`\3`\3`\3`\7`\u0305\n`\f`\16`\u0308\13`\3a\3"+
		"a\3b\3b\3b\5b\u030f\nb\3b\3b\3c\3c\3c\3c\3c\3c\3c\3c\3c\5c\u031c\nc\3"+
		"d\3d\3d\3d\3e\3e\3e\3e\6e\u0326\ne\re\16e\u0327\3e\5e\u032b\ne\3e\3e\3"+
		"f\3f\3f\3f\3f\6f\u0334\nf\rf\16f\u0335\3f\5f\u0339\nf\3f\3f\3g\3g\3g\3"+
		"h\3h\3h\3i\3i\3i\3j\3j\3k\3k\3k\3k\3k\3k\3k\3l\3l\3l\5l\u0352\nl\3l\3"+
		"l\3l\7l\u0357\nl\fl\16l\u035a\13l\5l\u035c\nl\3l\3l\3m\3m\3m\3n\5n\u0364"+
		"\nn\3n\3n\3n\3n\3n\5n\u036b\nn\3n\3n\5n\u036f\nn\3o\3o\3p\3p\3q\3q\3r"+
		"\3r\3s\3s\3t\3t\3u\3u\3v\3v\3v\5v\u0382\nv\3v\5v\u0385\nv\3v\5v\u0388"+
		"\nv\3w\3w\3x\3x\3x\3x\3x\3y\3y\3z\3z\3{\3{\3|\3|\5|\u0399\n|\3}\3}\3~"+
		"\3~\3\177\3\177\3\u0080\3\u0080\5\u0080\u03a3\n\u0080\3\u0081\3\u0081"+
		"\3\u0082\3\u0082\3\u0083\3\u0083\3\u0084\3\u0084\3\u0085\5\u0085\u03ae"+
		"\n\u0085\3\u0085\3\u0085\3\u0086\3\u0086\3\u0087\3\u0087\3\u0088\3\u0088"+
		"\3\u0089\3\u0089\3\u008a\3\u008a\3\u008b\3\u008b\3\u008b\2\u008c\2\4\6"+
		"\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRT"+
		"VXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e"+
		"\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6"+
		"\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be"+
		"\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6"+
		"\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee"+
		"\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106"+
		"\u0108\u010a\u010c\u010e\u0110\u0112\u0114\2\f\3\2\60\61\3\2ox\3\2\36"+
		" \3\2\u0083\u0089\3\2\u0092\u0094\3\2\u008b\u008d\4\2\u008a\u008a\u008e"+
		"\u0090\4\2))--\6\2ggjrtx\u009f\u009f\4\2\u008b\u008c\u0091\u0091\u0399"+
		"\2\u011c\3\2\2\2\4\u0120\3\2\2\2\6\u0125\3\2\2\2\b\u0127\3\2\2\2\n\u012a"+
		"\3\2\2\2\f\u0131\3\2\2\2\16\u0145\3\2\2\2\20\u0148\3\2\2\2\22\u014d\3"+
		"\2\2\2\24\u0150\3\2\2\2\26\u0152\3\2\2\2\30\u0156\3\2\2\2\32\u015e\3\2"+
		"\2\2\34\u0160\3\2\2\2\36\u0163\3\2\2\2 \u0165\3\2\2\2\"\u0169\3\2\2\2"+
		"$\u0171\3\2\2\2&\u0175\3\2\2\2(\u0177\3\2\2\2*\u017a\3\2\2\2,\u017c\3"+
		"\2\2\2.\u0188\3\2\2\2\60\u018c\3\2\2\2\62\u018e\3\2\2\2\64\u0196\3\2\2"+
		"\2\66\u019d\3\2\2\28\u01a1\3\2\2\2:\u01a3\3\2\2\2<\u01b0\3\2\2\2>\u01b7"+
		"\3\2\2\2@\u01bb\3\2\2\2B\u01c2\3\2\2\2D\u01c7\3\2\2\2F\u01cc\3\2\2\2H"+
		"\u01ce\3\2\2\2J\u01d4\3\2\2\2L\u01da\3\2\2\2N\u01e1\3\2\2\2P\u01e9\3\2"+
		"\2\2R\u01f4\3\2\2\2T\u01f6\3\2\2\2V\u01fc\3\2\2\2X\u01fe\3\2\2\2Z\u0204"+
		"\3\2\2\2\\\u020a\3\2\2\2^\u0213\3\2\2\2`\u0215\3\2\2\2b\u0219\3\2\2\2"+
		"d\u0220\3\2\2\2f\u0223\3\2\2\2h\u0229\3\2\2\2j\u022b\3\2\2\2l\u023f\3"+
		"\2\2\2n\u0253\3\2\2\2p\u025b\3\2\2\2r\u025f\3\2\2\2t\u0262\3\2\2\2v\u0264"+
		"\3\2\2\2x\u0268\3\2\2\2z\u026b\3\2\2\2|\u026d\3\2\2\2~\u0271\3\2\2\2\u0080"+
		"\u0274\3\2\2\2\u0082\u0276\3\2\2\2\u0084\u0279\3\2\2\2\u0086\u027b\3\2"+
		"\2\2\u0088\u027d\3\2\2\2\u008a\u0282\3\2\2\2\u008c\u0285\3\2\2\2\u008e"+
		"\u0287\3\2\2\2\u0090\u028f\3\2\2\2\u0092\u0293\3\2\2\2\u0094\u0295\3\2"+
		"\2\2\u0096\u029d\3\2\2\2\u0098\u02a2\3\2\2\2\u009a\u02a8\3\2\2\2\u009c"+
		"\u02aa\3\2\2\2\u009e\u02ad\3\2\2\2\u00a0\u02b5\3\2\2\2\u00a2\u02bd\3\2"+
		"\2\2\u00a4\u02c2\3\2\2\2\u00a6\u02c5\3\2\2\2\u00a8\u02cc\3\2\2\2\u00aa"+
		"\u02ce\3\2\2\2\u00ac\u02d1\3\2\2\2\u00ae\u02d6\3\2\2\2\u00b0\u02e1\3\2"+
		"\2\2\u00b2\u02e5\3\2\2\2\u00b4\u02e8\3\2\2\2\u00b6\u02ea\3\2\2\2\u00b8"+
		"\u02f3\3\2\2\2\u00ba\u02f5\3\2\2\2\u00bc\u02fe\3\2\2\2\u00be\u0300\3\2"+
		"\2\2\u00c0\u0309\3\2\2\2\u00c2\u030e\3\2\2\2\u00c4\u031b\3\2\2\2\u00c6"+
		"\u031d\3\2\2\2\u00c8\u0321\3\2\2\2\u00ca\u032e\3\2\2\2\u00cc\u033c\3\2"+
		"\2\2\u00ce\u033f\3\2\2\2\u00d0\u0342\3\2\2\2\u00d2\u0345\3\2\2\2\u00d4"+
		"\u0347\3\2\2\2\u00d6\u034e\3\2\2\2\u00d8\u035f\3\2\2\2\u00da\u036e\3\2"+
		"\2\2\u00dc\u0370\3\2\2\2\u00de\u0372\3\2\2\2\u00e0\u0374\3\2\2\2\u00e2"+
		"\u0376\3\2\2\2\u00e4\u0378\3\2\2\2\u00e6\u037a\3\2\2\2\u00e8\u037c\3\2"+
		"\2\2\u00ea\u037e\3\2\2\2\u00ec\u0389\3\2\2\2\u00ee\u038b\3\2\2\2\u00f0"+
		"\u0390\3\2\2\2\u00f2\u0392\3\2\2\2\u00f4\u0394\3\2\2\2\u00f6\u0398\3\2"+
		"\2\2\u00f8\u039a\3\2\2\2\u00fa\u039c\3\2\2\2\u00fc\u039e\3\2\2\2\u00fe"+
		"\u03a2\3\2\2\2\u0100\u03a4\3\2\2\2\u0102\u03a6\3\2\2\2\u0104\u03a8\3\2"+
		"\2\2\u0106\u03aa\3\2\2\2\u0108\u03ad\3\2\2\2\u010a\u03b1\3\2\2\2\u010c"+
		"\u03b3\3\2\2\2\u010e\u03b5\3\2\2\2\u0110\u03b7\3\2\2\2\u0112\u03b9\3\2"+
		"\2\2\u0114\u03bb\3\2\2\2\u0116\u0117\5\6\4\2\u0117\u0118\7\2\2\3\u0118"+
		"\u011d\3\2\2\2\u0119\u011a\5\4\3\2\u011a\u011b\7\2\2\3\u011b\u011d\3\2"+
		"\2\2\u011c\u0116\3\2\2\2\u011c\u0119\3\2\2\2\u011d\3\3\2\2\2\u011e\u0121"+
		"\5\b\5\2\u011f\u0121\5\f\7\2\u0120\u011e\3\2\2\2\u0120\u011f\3\2\2\2\u0121"+
		"\5\3\2\2\2\u0122\u0126\5j\66\2\u0123\u0126\5l\67\2\u0124\u0126\5\u00ea"+
		"v\2\u0125\u0122\3\2\2\2\u0125\u0123\3\2\2\2\u0125\u0124\3\2\2\2\u0126"+
		"\7\3\2\2\2\u0127\u0128\5\n\6\2\u0128\u0129\5\f\7\2\u0129\t\3\2\2\2\u012a"+
		"\u012b\7F\2\2\u012b\u012d\7E\2\2\u012c\u012e\7\24\2\2\u012d\u012c\3\2"+
		"\2\2\u012d\u012e\3\2\2\2\u012e\u012f\3\2\2\2\u012f\u0130\5\u00fc\177\2"+
		"\u0130\13\3\2\2\2\u0131\u0132\5\16\b\2\u0132\u0134\5\20\t\2\u0133\u0135"+
		"\5\22\n\2\u0134\u0133\3\2\2\2\u0134\u0135\3\2\2\2\u0135\u0137\3\2\2\2"+
		"\u0136\u0138\5\26\f\2\u0137\u0136\3\2\2\2\u0137\u0138\3\2\2\2\u0138\u013a"+
		"\3\2\2\2\u0139\u013b\5\34\17\2\u013a\u0139\3\2\2\2\u013a\u013b\3\2\2\2"+
		"\u013b\u013d\3\2\2\2\u013c\u013e\5 \21\2\u013d\u013c\3\2\2\2\u013d\u013e"+
		"\3\2\2\2\u013e\u0140\3\2\2\2\u013f\u0141\5(\25\2\u0140\u013f\3\2\2\2\u0140"+
		"\u0141\3\2\2\2\u0141\u0143\3\2\2\2\u0142\u0144\5\u0082B\2\u0143\u0142"+
		"\3\2\2\2\u0143\u0144\3\2\2\2\u0144\r\3\2\2\2\u0145\u0146\7\f\2\2\u0146"+
		"\u0147\5.\30\2\u0147\17\3\2\2\2\u0148\u0149\78\2\2\u0149\u014b\5@!\2\u014a"+
		"\u014c\5,\27\2\u014b\u014a\3\2\2\2\u014b\u014c\3\2\2\2\u014c\21\3\2\2"+
		"\2\u014d\u014e\7\67\2\2\u014e\u014f\5\24\13\2\u014f\23\3\2\2\2\u0150\u0151"+
		"\5\u0092J\2\u0151\25\3\2\2\2\u0152\u0153\7\64\2\2\u0153\u0154\7\65\2\2"+
		"\u0154\u0155\5\30\r\2\u0155\27\3\2\2\2\u0156\u015b\5\32\16\2\u0157\u0158"+
		"\7{\2\2\u0158\u015a\5\32\16\2\u0159\u0157\3\2\2\2\u015a\u015d\3\2\2\2"+
		"\u015b\u0159\3\2\2\2\u015b\u015c\3\2\2\2\u015c\31\3\2\2\2\u015d\u015b"+
		"\3\2\2\2\u015e\u015f\5\u0092J\2\u015f\33\3\2\2\2\u0160\u0161\7\66\2\2"+
		"\u0161\u0162\5\36\20\2\u0162\35\3\2\2\2\u0163\u0164\5\u0092J\2\u0164\37"+
		"\3\2\2\2\u0165\u0166\7\63\2\2\u0166\u0167\7\65\2\2\u0167\u0168\5\"\22"+
		"\2\u0168!\3\2\2\2\u0169\u016e\5$\23\2\u016a\u016b\7{\2\2\u016b\u016d\5"+
		"$\23\2\u016c\u016a\3\2\2\2\u016d\u0170\3\2\2\2\u016e\u016c\3\2\2\2\u016e"+
		"\u016f\3\2\2\2\u016f#\3\2\2\2\u0170\u016e\3\2\2\2\u0171\u0173\5\u0092"+
		"J\2\u0172\u0174\5&\24\2\u0173\u0172\3\2\2\2\u0173\u0174\3\2\2\2\u0174"+
		"%\3\2\2\2\u0175\u0176\t\2\2\2\u0176\'\3\2\2\2\u0177\u0178\7H\2\2\u0178"+
		"\u0179\5*\26\2\u0179)\3\2\2\2\u017a\u017b\5\u00e0q\2\u017b+\3\2\2\2\u017c"+
		"\u017d\7S\2\2\u017d\u017e\7}\2\2\u017e\u0181\5\u0092J\2\u017f\u0180\7"+
		"{\2\2\u0180\u0182\5\u0092J\2\u0181\u017f\3\2\2\2\u0182\u0183\3\2\2\2\u0183"+
		"\u0181\3\2\2\2\u0183\u0184\3\2\2\2\u0184\u0185\3\2\2\2\u0185\u0186\7~"+
		"\2\2\u0186-\3\2\2\2\u0187\u0189\5\60\31\2\u0188\u0187\3\2\2\2\u0188\u0189"+
		"\3\2\2\2\u0189\u018a\3\2\2\2\u018a\u018b\5\62\32\2\u018b/\3\2\2\2\u018c"+
		"\u018d\7\31\2\2\u018d\61\3\2\2\2\u018e\u0193\5\64\33\2\u018f\u0190\7{"+
		"\2\2\u0190\u0192\5\64\33\2\u0191\u018f\3\2\2\2\u0192\u0195\3\2\2\2\u0193"+
		"\u0191\3\2\2\2\u0193\u0194\3\2\2\2\u0194\63\3\2\2\2\u0195\u0193\3\2\2"+
		"\2\u0196\u0197\5\66\34\2\u0197\65\3\2\2\2\u0198\u019a\5\u0092J\2\u0199"+
		"\u019b\58\35\2\u019a\u0199\3\2\2\2\u019a\u019b\3\2\2\2\u019b\u019e\3\2"+
		"\2\2\u019c\u019e\5> \2\u019d\u0198\3\2\2\2\u019d\u019c\3\2\2\2\u019e\67"+
		"\3\2\2\2\u019f\u01a2\5:\36\2\u01a0\u01a2\5<\37\2\u01a1\u019f\3\2\2\2\u01a1"+
		"\u01a0\3\2\2\2\u01a29\3\2\2\2\u01a3\u01a4\7*\2\2\u01a4\u01a5\7}\2\2\u01a5"+
		"\u01aa\5\u0104\u0083\2\u01a6\u01a7\7{\2\2\u01a7\u01a9\5\u0104\u0083\2"+
		"\u01a8\u01a6\3\2\2\2\u01a9\u01ac\3\2\2\2\u01aa\u01a8\3\2\2\2\u01aa\u01ab"+
		"\3\2\2\2\u01ab\u01ad\3\2\2\2\u01ac\u01aa\3\2\2\2\u01ad\u01ae\7~\2\2\u01ae"+
		";\3\2\2\2\u01af\u01b1\7*\2\2\u01b0\u01af\3\2\2\2\u01b0\u01b1\3\2\2\2\u01b1"+
		"\u01b2\3\2\2\2\u01b2\u01b3\5\u0104\u0083\2\u01b3=\3\2\2\2\u01b4\u01b5"+
		"\5\u00fc\177\2\u01b5\u01b6\7y\2\2\u01b6\u01b8\3\2\2\2\u01b7\u01b4\3\2"+
		"\2\2\u01b7\u01b8\3\2\2\2\u01b8\u01b9\3\2\2\2\u01b9\u01ba\7\u008e\2\2\u01ba"+
		"?\3\2\2\2\u01bb\u01bf\5F$\2\u01bc\u01be\5B\"\2\u01bd\u01bc\3\2\2\2\u01be"+
		"\u01c1\3\2\2\2\u01bf\u01bd\3\2\2\2\u01bf\u01c0\3\2\2\2\u01c0A\3\2\2\2"+
		"\u01c1\u01bf\3\2\2\2\u01c2\u01c3\5R*\2\u01c3\u01c5\5F$\2\u01c4\u01c6\5"+
		"D#\2\u01c5\u01c4\3\2\2\2\u01c5\u01c6\3\2\2\2\u01c6C\3\2\2\2\u01c7\u01c8"+
		"\79\2\2\u01c8\u01c9\5\u0092J\2\u01c9E\3\2\2\2\u01ca\u01cd\5b\62\2\u01cb"+
		"\u01cd\5H%\2\u01cc\u01ca\3\2\2\2\u01cc\u01cb\3\2\2\2\u01cdG\3\2\2\2\u01ce"+
		"\u01cf\7`\2\2\u01cf\u01d0\5\u0112\u008a\2\u01d0\u01d2\5J&\2\u01d1\u01d3"+
		"\5f\64\2\u01d2\u01d1\3\2\2\2\u01d2\u01d3\3\2\2\2\u01d3I\3\2\2\2\u01d4"+
		"\u01d5\7\177\2\2\u01d5\u01d6\5P)\2\u01d6\u01d7\7{\2\2\u01d7\u01d8\5L\'"+
		"\2\u01d8\u01d9\7\u0080\2\2\u01d9K\3\2\2\2\u01da\u01db\7b\2\2\u01db\u01dd"+
		"\7}\2\2\u01dc\u01de\5N(\2\u01dd\u01dc\3\2\2\2\u01dd\u01de\3\2\2\2\u01de"+
		"\u01df\3\2\2\2\u01df\u01e0\7~\2\2\u01e0M\3\2\2\2\u01e1\u01e6\5\u0092J"+
		"\2\u01e2\u01e3\7{\2\2\u01e3\u01e5\5\u0092J\2\u01e4\u01e2\3\2\2\2\u01e5"+
		"\u01e8\3\2\2\2\u01e6\u01e4\3\2\2\2\u01e6\u01e7\3\2\2\2\u01e7O\3\2\2\2"+
		"\u01e8\u01e6\3\2\2\2\u01e9\u01ea\7a\2\2\u01ea\u01eb\7}\2\2\u01eb\u01ec"+
		"\5n8\2\u01ec\u01ed\7~\2\2\u01edQ\3\2\2\2\u01ee\u01f5\5^\60\2\u01ef\u01f5"+
		"\5\\/\2\u01f0\u01f5\5Z.\2\u01f1\u01f5\5X-\2\u01f2\u01f5\5V,\2\u01f3\u01f5"+
		"\5T+\2\u01f4\u01ee\3\2\2\2\u01f4\u01ef\3\2\2\2\u01f4\u01f0\3\2\2\2\u01f4"+
		"\u01f1\3\2\2\2\u01f4\u01f2\3\2\2\2\u01f4\u01f3\3\2\2\2\u01f5S\3\2\2\2"+
		"\u01f6\u01f7\7C\2\2\u01f7\u01f8\7:\2\2\u01f8U\3\2\2\2\u01f9\u01fd\7{\2"+
		"\2\u01fa\u01fb\7?\2\2\u01fb\u01fd\7:\2\2\u01fc\u01f9\3\2\2\2\u01fc\u01fa"+
		"\3\2\2\2\u01fdW\3\2\2\2\u01fe\u0200\7<\2\2\u01ff\u0201\7>\2\2\u0200\u01ff"+
		"\3\2\2\2\u0200\u0201\3\2\2\2\u0201\u0202\3\2\2\2\u0202\u0203\7:\2\2\u0203"+
		"Y\3\2\2\2\u0204\u0206\7D\2\2\u0205\u0207\7>\2\2\u0206\u0205\3\2\2\2\u0206"+
		"\u0207\3\2\2\2\u0207\u0208\3\2\2\2\u0208\u0209\7:\2\2\u0209[\3\2\2\2\u020a"+
		"\u020c\7A\2\2\u020b\u020d\7>\2\2\u020c\u020b\3\2\2\2\u020c\u020d\3\2\2"+
		"\2\u020d\u020e\3\2\2\2\u020e\u020f\7:\2\2\u020f]\3\2\2\2\u0210\u0214\7"+
		":\2\2\u0211\u0212\7B\2\2\u0212\u0214\7:\2\2\u0213\u0210\3\2\2\2\u0213"+
		"\u0211\3\2\2\2\u0214_\3\2\2\2\u0215\u0216\7}\2\2\u0216\u0217\5\f\7\2\u0217"+
		"\u0218\7~\2\2\u0218a\3\2\2\2\u0219\u021b\5h\65\2\u021a\u021c\5f\64\2\u021b"+
		"\u021a\3\2\2\2\u021b\u021c\3\2\2\2\u021c\u021e\3\2\2\2\u021d\u021f\5d"+
		"\63\2\u021e\u021d\3\2\2\2\u021e\u021f\3\2\2\2\u021fc\3\2\2\2\u0220\u0221"+
		"\7T\2\2\u0221e\3\2\2\2\u0222\u0224\7*\2\2\u0223\u0222\3\2\2\2\u0223\u0224"+
		"\3\2\2\2\u0224\u0225\3\2\2\2\u0225\u0226\5\u0114\u008b\2\u0226g\3\2\2"+
		"\2\u0227\u022a\5\u00fc\177\2\u0228\u022a\5`\61\2\u0229\u0227\3\2\2\2\u0229"+
		"\u0228\3\2\2\2\u022ai\3\2\2\2\u022b\u022c\7\3\2\2\u022c\u022d\7\23\2\2"+
		"\u022d\u022e\7\24\2\2\u022e\u0233\5\u00fc\177\2\u022f\u0230\7}\2\2\u0230"+
		"\u0231\5n8\2\u0231\u0232\7~\2\2\u0232\u0234\3\2\2\2\u0233\u022f\3\2\2"+
		"\2\u0233\u0234\3\2\2\2\u0234\u0236\3\2\2\2\u0235\u0237\5\u008aF\2\u0236"+
		"\u0235\3\2\2\2\u0236\u0237\3\2\2\2\u0237\u0239\3\2\2\2\u0238\u023a\5p"+
		"9\2\u0239\u0238\3\2\2\2\u0239\u023a\3\2\2\2\u023a\u023b\3\2\2\2\u023b"+
		"\u023d\5v<\2\u023c\u023e\5\u0082B\2\u023d\u023c\3\2\2\2\u023d\u023e\3"+
		"\2\2\2\u023ek\3\2\2\2\u023f\u0240\7\3\2\2\u0240\u0241\7\25\2\2\u0241\u0242"+
		"\7\24\2\2\u0242\u0247\5\u00fc\177\2\u0243\u0244\7}\2\2\u0244\u0245\5n"+
		"8\2\u0245\u0246\7~\2\2\u0246\u0248\3\2\2\2\u0247\u0243\3\2\2\2\u0247\u0248"+
		"\3\2\2\2\u0248\u024a\3\2\2\2\u0249\u024b\5\u008aF\2\u024a\u0249\3\2\2"+
		"\2\u024a\u024b\3\2\2\2\u024b\u024d\3\2\2\2\u024c\u024e\5p9\2\u024d\u024c"+
		"\3\2\2\2\u024d\u024e\3\2\2\2\u024e\u024f\3\2\2\2\u024f\u0251\5|?\2\u0250"+
		"\u0252\5\u0082B\2\u0251\u0250\3\2\2\2\u0251\u0252\3\2\2\2\u0252m\3\2\2"+
		"\2\u0253\u0258\5\u0088E\2\u0254\u0255\7{\2\2\u0255\u0257\5\u0088E\2\u0256"+
		"\u0254\3\2\2\2\u0257\u025a\3\2\2\2\u0258\u0256\3\2\2\2\u0258\u0259\3\2"+
		"\2\2\u0259o\3\2\2\2\u025a\u0258\3\2\2\2\u025b\u025d\5r:\2\u025c\u025e"+
		"\5t;\2\u025d\u025c\3\2\2\2\u025d\u025e\3\2\2\2\u025eq\3\2\2\2\u025f\u0260"+
		"\7\17\2\2\u0260\u0261\5\u00f6|\2\u0261s\3\2\2\2\u0262\u0263\5\u00eex\2"+
		"\u0263u\3\2\2\2\u0264\u0266\5x=\2\u0265\u0267\5z>\2\u0266\u0265\3\2\2"+
		"\2\u0266\u0267\3\2\2\2\u0267w\3\2\2\2\u0268\u0269\7\22\2\2\u0269\u026a"+
		"\5\u00f6|\2\u026ay\3\2\2\2\u026b\u026c\5\u00eex\2\u026c{\3\2\2\2\u026d"+
		"\u026f\5~@\2\u026e\u0270\5\u0080A\2\u026f\u026e\3\2\2\2\u026f\u0270\3"+
		"\2\2\2\u0270}\3\2\2\2\u0271\u0272\7\26\2\2\u0272\u0273\5\u00f6|\2\u0273"+
		"\177\3\2\2\2\u0274\u0275\5\u00eex\2\u0275\u0081\3\2\2\2\u0276\u0277\7"+
		";\2\2\u0277\u0278\5\u00e0q\2\u0278\u0083\3\2\2\2\u0279\u027a\t\3\2\2\u027a"+
		"\u0085\3\2\2\2\u027b\u027c\5\u0084C\2\u027c\u0087\3\2\2\2\u027d\u027e"+
		"\5\u00f4{\2\u027e\u0280\5\u0086D\2\u027f\u0281\5\u008aF\2\u0280\u027f"+
		"\3\2\2\2\u0280\u0281\3\2\2\2\u0281\u0089\3\2\2\2\u0282\u0283\7\r\2\2\u0283"+
		"\u0284\5\u008cG\2\u0284\u008b\3\2\2\2\u0285\u0286\7\u009b\2\2\u0286\u008d"+
		"\3\2\2\2\u0287\u028c\5\u0090I\2\u0288\u0289\7{\2\2\u0289\u028b\5\u0090"+
		"I\2\u028a\u0288\3\2\2\2\u028b\u028e\3\2\2\2\u028c\u028a\3\2\2\2\u028c"+
		"\u028d\3\2\2\2\u028d\u008f\3\2\2\2\u028e\u028c\3\2\2\2\u028f\u0290\5\u00f0"+
		"y\2\u0290\u0291\7\u0083\2\2\u0291\u0292\5\u00f2z\2\u0292\u0091\3\2\2\2"+
		"\u0293\u0294\5\u0094K\2\u0294\u0093\3\2\2\2\u0295\u029a\5\u0096L\2\u0296"+
		"\u0297\7\33\2\2\u0297\u0299\5\u0096L\2\u0298\u0296\3\2\2\2\u0299\u029c"+
		"\3\2\2\2\u029a\u0298\3\2\2\2\u029a\u029b\3\2\2\2\u029b\u0095\3\2\2\2\u029c"+
		"\u029a\3\2\2\2\u029d\u029e\5\u0098M\2\u029e\u029f\7\32\2\2\u029f\u02a0"+
		"\5\u0098M\2\u02a0\u0097\3\2\2\2\u02a1\u02a3\5\u0106\u0084\2\u02a2\u02a1"+
		"\3\2\2\2\u02a2\u02a3\3\2\2\2\u02a3\u02a4\3\2\2\2\u02a4\u02a5\5\u009aN"+
		"\2\u02a5\u0099\3\2\2\2\u02a6\u02a9\5\u009eP\2\u02a7\u02a9\5\u009cO\2\u02a8"+
		"\u02a6\3\2\2\2\u02a8\u02a7\3\2\2\2\u02a9\u009b\3\2\2\2\u02aa\u02ab\7\'"+
		"\2\2\u02ab\u02ac\5\u00b0Y\2\u02ac\u009d\3\2\2\2\u02ad\u02b3\5\u00a0Q\2"+
		"\u02ae\u02af\7,\2\2\u02af\u02b4\5\u0108\u0085\2\u02b0\u02b4\5\u00a2R\2"+
		"\u02b1\u02b4\5\u00a6T\2\u02b2\u02b4\5\u00acW\2\u02b3\u02ae\3\2\2\2\u02b3"+
		"\u02b0\3\2\2\2\u02b3\u02b1\3\2\2\2\u02b3\u02b2\3\2\2\2\u02b3\u02b4\3\2"+
		"\2\2\u02b4\u009f\3\2\2\2\u02b5\u02b9\5\u00b6\\\2\u02b6\u02b8\5\u00b2Z"+
		"\2\u02b7\u02b6\3\2\2\2\u02b8\u02bb\3\2\2\2\u02b9\u02b7\3\2\2\2\u02b9\u02ba"+
		"\3\2\2\2\u02ba\u00a1\3\2\2\2\u02bb\u02b9\3\2\2\2\u02bc\u02be\5\u0106\u0084"+
		"\2\u02bd\u02bc\3\2\2\2\u02bd\u02be\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf\u02c0"+
		"\5\u00a4S\2\u02c0\u02c1\5\u00b6\\\2\u02c1\u00a3\3\2\2\2\u02c2\u02c3\t"+
		"\4\2\2\u02c3\u00a5\3\2\2\2\u02c4\u02c6\5\u0106\u0084\2\u02c5\u02c4\3\2"+
		"\2\2\u02c5\u02c6\3\2\2\2\u02c6\u02c7\3\2\2\2\u02c7\u02c8\7\34\2\2\u02c8"+
		"\u02c9\5\u00aaV\2\u02c9\u02ca\7\32\2\2\u02ca\u02cb\5\u00a8U\2\u02cb\u00a7"+
		"\3\2\2\2\u02cc\u02cd\5\u00b6\\\2\u02cd\u00a9\3\2\2\2\u02ce\u02cf\5\u00b6"+
		"\\\2\u02cf\u00ab\3\2\2\2\u02d0\u02d2\5\u0106\u0084\2\u02d1\u02d0\3\2\2"+
		"\2\u02d1\u02d2\3\2\2\2\u02d2\u02d3\3\2\2\2\u02d3\u02d4\7\35\2\2\u02d4"+
		"\u02d5\5\u00aeX\2\u02d5\u00ad\3\2\2\2\u02d6\u02d7\7}\2\2\u02d7\u02dc\5"+
		"\u0092J\2\u02d8\u02d9\7{\2\2\u02d9\u02db\5\u0092J\2\u02da\u02d8\3\2\2"+
		"\2\u02db\u02de\3\2\2\2\u02dc\u02da\3\2\2\2\u02dc\u02dd\3\2\2\2\u02dd\u02df"+
		"\3\2\2\2\u02de\u02dc\3\2\2\2\u02df\u02e0\7~\2\2\u02e0\u00af\3\2\2\2\u02e1"+
		"\u02e2\7}\2\2\u02e2\u02e3\5\f\7\2\u02e3\u02e4\7~\2\2\u02e4\u00b1\3\2\2"+
		"\2\u02e5\u02e6\5\u00b4[\2\u02e6\u02e7\5\u00b6\\\2\u02e7\u00b3\3\2\2\2"+
		"\u02e8\u02e9\t\5\2\2\u02e9\u00b5\3\2\2\2\u02ea\u02f0\5\u00ba^\2\u02eb"+
		"\u02ec\5\u00b8]\2\u02ec\u02ed\5\u00ba^\2\u02ed\u02ef\3\2\2\2\u02ee\u02eb"+
		"\3\2\2\2\u02ef\u02f2\3\2\2\2\u02f0\u02ee\3\2\2\2\u02f0\u02f1\3\2\2\2\u02f1"+
		"\u00b7\3\2\2\2\u02f2\u02f0\3\2\2\2\u02f3\u02f4\t\6\2\2\u02f4\u00b9\3\2"+
		"\2\2\u02f5\u02fb\5\u00be`\2\u02f6\u02f7\5\u00bc_\2\u02f7\u02f8\5\u00be"+
		"`\2\u02f8\u02fa\3\2\2\2\u02f9\u02f6\3\2\2\2\u02fa\u02fd\3\2\2\2\u02fb"+
		"\u02f9\3\2\2\2\u02fb\u02fc\3\2\2\2\u02fc\u00bb\3\2\2\2\u02fd\u02fb\3\2"+
		"\2\2\u02fe\u02ff\t\7\2\2\u02ff\u00bd\3\2\2\2\u0300\u0306\5\u00c2b\2\u0301"+
		"\u0302\5\u00c0a\2\u0302\u0303\5\u00c2b\2\u0303\u0305\3\2\2\2\u0304\u0301"+
		"\3\2\2\2\u0305\u0308\3\2\2\2\u0306\u0304\3\2\2\2\u0306\u0307\3\2\2\2\u0307"+
		"\u00bf\3\2\2\2\u0308\u0306\3\2\2\2\u0309\u030a\t\b\2\2\u030a\u00c1\3\2"+
		"\2\2\u030b\u030c\5\u010a\u0086\2\u030c\u030d\7y\2\2\u030d\u030f\3\2\2"+
		"\2\u030e\u030b\3\2\2\2\u030e\u030f\3\2\2\2\u030f\u0310\3\2\2\2\u0310\u0311"+
		"\5\u00c4c\2\u0311\u00c3\3\2\2\2\u0312\u031c\5\u010c\u0087\2\u0313\u031c"+
		"\5\u00dan\2\u0314\u031c\5\u00d8m\2\u0315\u031c\5\u00d6l\2\u0316\u031c"+
		"\5\u00d4k\2\u0317\u031c\5\u00caf\2\u0318\u031c\5\u00c8e\2\u0319\u031c"+
		"\5\u00f4{\2\u031a\u031c\5\u00c6d\2\u031b\u0312\3\2\2\2\u031b\u0313\3\2"+
		"\2\2\u031b\u0314\3\2\2\2\u031b\u0315\3\2\2\2\u031b\u0316\3\2\2\2\u031b"+
		"\u0317\3\2\2\2\u031b\u0318\3\2\2\2\u031b\u0319\3\2\2\2\u031b\u031a\3\2"+
		"\2\2\u031c\u00c5\3\2\2\2\u031d\u031e\7}\2\2\u031e\u031f\5\u0092J\2\u031f"+
		"\u0320\7~\2\2\u0320\u00c7\3\2\2\2\u0321\u0325\7!\2\2\u0322\u0323\5\u00d0"+
		"i\2\u0323\u0324\5\u00ceh\2\u0324\u0326\3\2\2\2\u0325\u0322\3\2\2\2\u0326"+
		"\u0327\3\2\2\2\u0327\u0325\3\2\2\2\u0327\u0328\3\2\2\2\u0328\u032a\3\2"+
		"\2\2\u0329\u032b\5\u00ccg\2\u032a\u0329\3\2\2\2\u032a\u032b\3\2\2\2\u032b"+
		"\u032c\3\2\2\2\u032c\u032d\7%\2\2\u032d\u00c9\3\2\2\2\u032e\u032f\7!\2"+
		"\2\u032f\u0333\5\u00d2j\2\u0330\u0331\5\u00d0i\2\u0331\u0332\5\u00ceh"+
		"\2\u0332\u0334\3\2\2\2\u0333\u0330\3\2\2\2\u0334\u0335\3\2\2\2\u0335\u0333"+
		"\3\2\2\2\u0335\u0336\3\2\2\2\u0336\u0338\3\2\2\2\u0337\u0339\5\u00ccg"+
		"\2\u0338\u0337\3\2\2\2\u0338\u0339\3\2\2\2\u0339\u033a\3\2\2\2\u033a\u033b"+
		"\7%\2\2\u033b\u00cb\3\2\2\2\u033c\u033d\7$\2\2\u033d\u033e\5\u0092J\2"+
		"\u033e\u00cd\3\2\2\2\u033f\u0340\7#\2\2\u0340\u0341\5\u0092J\2\u0341\u00cf"+
		"\3\2\2\2\u0342\u0343\7\"\2\2\u0343\u0344\5\u0092J\2\u0344\u00d1\3\2\2"+
		"\2\u0345\u0346\5\u0092J\2\u0346\u00d3\3\2\2\2\u0347\u0348\7&\2\2\u0348"+
		"\u0349\7}\2\2\u0349\u034a\5\u0092J\2\u034a\u034b\7*\2\2\u034b\u034c\5"+
		"\u0084C\2\u034c\u034d\7~\2\2\u034d\u00d5\3\2\2\2\u034e\u034f\5\u0110\u0089"+
		"\2\u034f\u0351\7}\2\2\u0350\u0352\5\60\31\2\u0351\u0350\3\2\2\2\u0351"+
		"\u0352\3\2\2\2\u0352\u035b\3\2\2\2\u0353\u0358\5\66\34\2\u0354\u0355\7"+
		"{\2\2\u0355\u0357\5\66\34\2\u0356\u0354\3\2\2\2\u0357\u035a\3\2\2\2\u0358"+
		"\u0356\3\2\2\2\u0358\u0359\3\2\2\2\u0359\u035c\3\2\2\2\u035a\u0358\3\2"+
		"\2\2\u035b\u0353\3\2\2\2\u035b\u035c\3\2\2\2\u035c\u035d\3\2\2\2\u035d"+
		"\u035e\7~\2\2\u035e\u00d7\3\2\2\2\u035f\u0360\7_\2\2\u0360\u0361\5\u0092"+
		"J\2\u0361\u00d9\3\2\2\2\u0362\u0364\5\u010e\u0088\2\u0363\u0362\3\2\2"+
		"\2\u0363\u0364\3\2\2\2\u0364\u036a\3\2\2\2\u0365\u036b\5\u00e0q\2\u0366"+
		"\u036b\5\u00e8u\2\u0367\u036b\5\u00e6t\2\u0368\u036b\5\u00e4s\2\u0369"+
		"\u036b\5\u00e2r\2\u036a\u0365\3\2\2\2\u036a\u0366\3\2\2\2\u036a\u0367"+
		"\3\2\2\2\u036a\u0368\3\2\2\2\u036a\u0369\3\2\2\2\u036b\u036f\3\2\2\2\u036c"+
		"\u036f\5\u00dep\2\u036d\u036f\5\u00dco\2\u036e\u0363\3\2\2\2\u036e\u036c"+
		"\3\2\2\2\u036e\u036d\3\2\2\2\u036f\u00db\3\2\2\2\u0370\u0371\t\t\2\2\u0371"+
		"\u00dd\3\2\2\2\u0372\u0373\7\u009b\2\2\u0373\u00df\3\2\2\2\u0374\u0375"+
		"\7\u009d\2\2\u0375\u00e1\3\2\2\2\u0376\u0377\7\u009a\2\2\u0377\u00e3\3"+
		"\2\2\2\u0378\u0379\7\u0099\2\2\u0379\u00e5\3\2\2\2\u037a\u037b\7\u0098"+
		"\2\2\u037b\u00e7\3\2\2\2\u037c\u037d\7\u0097\2\2\u037d\u00e9\3\2\2\2\u037e"+
		"\u037f\7\27\2\2\u037f\u0381\7\30\2\2\u0380\u0382\5\u0102\u0082\2\u0381"+
		"\u0380\3\2\2\2\u0381\u0382\3\2\2\2\u0382\u0384\3\2\2\2\u0383\u0385\5\u00fe"+
		"\u0080\2\u0384\u0383\3\2\2\2\u0384\u0385\3\2\2\2\u0385\u0387\3\2\2\2\u0386"+
		"\u0388\5\u0100\u0081\2\u0387\u0386\3\2\2\2\u0387\u0388\3\2\2\2\u0388\u00eb"+
		"\3\2\2\2\u0389\u038a\t\n\2\2\u038a\u00ed\3\2\2\2\u038b\u038c\7\21\2\2"+
		"\u038c\u038d\7}\2\2\u038d\u038e\5\u008eH\2\u038e\u038f\7~\2\2\u038f\u00ef"+
		"\3\2\2\2\u0390\u0391\7\u009b\2\2\u0391\u00f1\3\2\2\2\u0392\u0393\7\u009b"+
		"\2\2\u0393\u00f3\3\2\2\2\u0394\u0395\5\u00ecw\2\u0395\u00f5\3\2\2\2\u0396"+
		"\u0399\5\u00f8}\2\u0397\u0399\5\u00fa~\2\u0398\u0396\3\2\2\2\u0398\u0397"+
		"\3\2\2\2\u0399\u00f7\3\2\2\2\u039a\u039b\5\u00ecw\2\u039b\u00f9\3\2\2"+
		"\2\u039c\u039d\7\u009b\2\2\u039d\u00fb\3\2\2\2\u039e\u039f\5\u00ecw\2"+
		"\u039f\u00fd\3\2\2\2\u03a0\u03a3\5\u00ecw\2\u03a1\u03a3\5\u00e0q\2\u03a2"+
		"\u03a0\3\2\2\2\u03a2\u03a1\3\2\2\2\u03a3\u00ff\3\2\2\2\u03a4\u03a5\7\u009b"+
		"\2\2\u03a5\u0101\3\2\2\2\u03a6\u03a7\7\16\2\2\u03a7\u0103\3\2\2\2\u03a8"+
		"\u03a9\5\u00ecw\2\u03a9\u0105\3\2\2\2\u03aa\u03ab\7/\2\2\u03ab\u0107\3"+
		"\2\2\2\u03ac\u03ae\5\u0106\u0084\2\u03ad\u03ac\3\2\2\2\u03ad\u03ae\3\2"+
		"\2\2\u03ae\u03af\3\2\2\2\u03af\u03b0\7+\2\2\u03b0\u0109\3\2\2\2\u03b1"+
		"\u03b2\5\u00ecw\2\u03b2\u010b\3\2\2\2\u03b3\u03b4\7+\2\2\u03b4\u010d\3"+
		"\2\2\2\u03b5\u03b6\t\13\2\2\u03b6\u010f\3\2\2\2\u03b7\u03b8\5\u00ecw\2"+
		"\u03b8\u0111\3\2\2\2\u03b9\u03ba\5\u00ecw\2\u03ba\u0113\3\2\2\2\u03bb"+
		"\u03bc\5\u00ecw\2\u03bc\u0115\3\2\2\2U\u011c\u0120\u0125\u012d\u0134\u0137"+
		"\u013a\u013d\u0140\u0143\u014b\u015b\u016e\u0173\u0183\u0188\u0193\u019a"+
		"\u019d\u01a1\u01aa\u01b0\u01b7\u01bf\u01c5\u01cc\u01d2\u01dd\u01e6\u01f4"+
		"\u01fc\u0200\u0206\u020c\u0213\u021b\u021e\u0223\u0229\u0233\u0236\u0239"+
		"\u023d\u0247\u024a\u024d\u0251\u0258\u025d\u0266\u026f\u0280\u028c\u029a"+
		"\u02a2\u02a8\u02b3\u02b9\u02bd\u02c5\u02d1\u02dc\u02f0\u02fb\u0306\u030e"+
		"\u031b\u0327\u032a\u0335\u0338\u0351\u0358\u035b\u0363\u036a\u036e\u0381"+
		"\u0384\u0387\u0398\u03a2\u03ad";
	public static final ATN _ATN =
		ATNSimulator.deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}